다리 만들기

https://www.acmicpc.net/problem/2146

문제

여러 섬으로 이루어진 나라가 있다.

이 나라의 대통령은 섬을 잇는 다리를 만들겠다는 공약으로 인기몰이를 해 당선될 수 있었다.

하지만 막상 대통령에 취임하자, 다리를 놓는다는 것이 아깝다는 생각을 하게 되었다.

그래서 그는, 생색내는 식으로 한 섬과 다른 섬을 잇는 다리 하나만을 만들기로 하였고, 그 또한 다리를 가장 짧게 하여 돈을 아끼려 하였다.

이 나라는 N×N크기의 이차원 평면상에 존재한다. 이 나라는 여러 섬으로 이루어져 있으며, 섬이란 동서남북으로 육지가 붙어있는 덩어리를 말한다.

다음은 세 개의 섬으로 이루어진 나라의 지도이다.

위의 그림에서 색이 있는 부분이 육지이고, 색이 없는 부분이 바다이다.

이 바다에 가장 짧은 다리를 놓아 두 대륙을 연결하고자 한다.

가장 짧은 다리란, 다리가 격자에서 차지하는 칸의 수가 가장 작은 다리를 말한다.

다음 그림에서 두 대륙을 연결하는 다리를 볼 수 있다.

물론 위의 방법 외에도 다리를 놓는 방법이 여러 가지 있으나, 위의 경우가 놓는 다리의 길이가 3으로 가장 짧다

(물론 길이가 3인 다른 다리를 놓을 수 있는 방법도 몇 가지 있다).

지도가 주어질 때, 가장 짧은 다리 하나를 놓아 두 대륙을 연결하는 방법을 찾으시오.

입력

첫 줄에는 지도의 크기 N(100이하의 자연수)가 주어진다.

그 다음 N줄에는 N개의 숫자가 빈칸을 사이에 두고 주어지며, 0은 바다, 1은 육지를 나타낸다.

항상 두 개 이상의 섬이 있는 데이터만 입력으로 주어진다.

출력

첫째 줄에 가장 짧은 다리의 길이를 출력한다.

예제 입력 1

10
1 1 1 0 0 0 0 1 1 1
1 1 1 1 0 0 0 0 1 1
1 0 1 1 0 0 0 0 1 1
0 0 1 1 1 0 0 0 0 1
0 0 0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0

예제 출력 1

3

추가 반례

https://www.acmicpc.net/board/search/all/problem/2146

예제 입력 A

4
1 0 0 1
0 0 0 0
0 1 1 0
0 0 0 0

예제 출력 A

2

예제 입력 B

6
1 0 0 1 1 1
1 0 0 0 0 1
1 0 0 0 0 0
1 0 0 0 0 1
1 1 1 1 1 1
0 0 0 0 0 0

예제 출력 B

1

예제 입력 C

4
1 0 0 0
0 0 0 0
0 0 0 1
0 0 0 1

예제 출력 C

4

출처

• 빠진 조건을 찾은 사람: choiking10
• 데이터를 추가한 사람: hello70825, ohyuni
• 잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색

통과된 코드

1. 맵을 순회하면서 BFS를 이용하여 섬을 구분

2. 섬마다 가장 가까운 다른 섬까지의 거리를 구함

#include <iostream>
#include <queue>

using namespace std;

constexpr int MAX = 100;
int _QSize;

int _MAP[MAX][MAX];
bool _IsVisted[MAX][MAX];

int DxDy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };

void ClearMap()
{
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++) {
			_IsVisted[i][j] = false;
			if (_MAP[i][j] <= 0)
				_MAP[i][j] = 0;
		}

}

void SortOutTypesIslands(const int _cntSort, const int _startI, const int _startJ)
{
	queue<pair<int, int>> SortQueue;
	SortQueue.push({ _startI, _startJ });
	_MAP[_startI][_startJ] = _cntSort;
	while (!SortQueue.empty())
	{
		pair<int, int> _cntXY = SortQueue.front();
		SortQueue.pop();

		for (int i = 0; i < 4; i++) {
			int _Tx = _cntXY.first + DxDy[i][0];
			int _Ty = _cntXY.second + DxDy[i][1];

			if (_Tx >= _QSize || _Ty >= _QSize || _Tx < 0 || _Ty < 0)
				continue;
			
			if (_MAP[_Tx][_Ty] == 1) {
				_MAP[_Tx][_Ty] = _cntSort;
				SortQueue.push({ _Tx, _Ty });
			}

		}

	}
}


int FindShortBridge(queue<pair<int, int>>& TypeQueue, const int _cntType)
{
	int _shortLen = INT32_MAX;

	while (!TypeQueue.empty())
	{
		pair<int, int> _cntXY = TypeQueue.front();
		TypeQueue.pop();

		int _cnt;
		if (_MAP[_cntXY.first][_cntXY.second] == _cntType) _cnt = 0;
		else _cnt = _MAP[_cntXY.first][_cntXY.second];

		for (int i = 0; i < 4; i++) {
			int _Tx = _cntXY.first + DxDy[i][0];
			int _Ty = _cntXY.second + DxDy[i][1];

			if (_Tx >= _QSize || _Ty >= _QSize || _Tx < 0 || _Ty < 0 || _IsVisted[_Tx][_Ty])
				continue;

			if (_MAP[_Tx][_Ty] != _cntType && _MAP[_Tx][_Ty] >= 1) {
				if (_shortLen > -_cnt) 
					_shortLen = -_cnt;
				break;
			}

			if (_MAP[_Tx][_Ty] == 0) {
				TypeQueue.push({ _Tx, _Ty });
				_IsVisted[_Tx][_Ty] = true;
				_MAP[_Tx][_Ty] = _cnt - 1;

			}
		}

	}

	return _shortLen;
}


int main()
{ 
	int _res = INT32_MAX;
	cin >> _QSize;
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++)
			cin >> _MAP[i][j];

	int _Sort = 2;
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++)
			if (_MAP[i][j] == 1) {
				SortOutTypesIslands(_Sort, i, j);
				_Sort++;
			}

	while (_Sort != 1)
	{
		queue<pair<int, int>> TypeQueue;
		for (int i = 0; i < _QSize; i++)
			for (int j = 0; j < _QSize; j++)
				if (_MAP[i][j] == _Sort) {
					TypeQueue.push({ i, j });
					_IsVisted[i][j] = true;
				}

		ClearMap();
		_res = min(_res, FindShortBridge(TypeQueue, _Sort));
		_Sort--;
	}

	cout << _res;

	return 0;
}

섬의 좌표를 구분단계에서 미리 저장하여 비효율적인 부분을 제거

#include <iostream>
#include <queue>

using namespace std;

constexpr int MAX = 100;
int _QSize;

int _MAP[MAX][MAX];
bool _IsVisted[MAX][MAX];

int DxDy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };

void ClearMap()
{
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++) {
			_IsVisted[i][j] = false;
			if (_MAP[i][j] <= 0)
				_MAP[i][j] = 0;
		}

}

queue<pair<unsigned char, unsigned char>> SortOutTypesIslands(const int _cntSort, const int _startI, const int _startJ)
{
	queue<pair<unsigned char, unsigned char>> TotalPosQueue;

	queue<pair<int, int>> SortQueue;
	SortQueue.push({ _startI, _startJ });
	TotalPosQueue.push({ _startI, _startJ });
	_MAP[_startI][_startJ] = _cntSort;
	while (!SortQueue.empty())
	{
		pair<int, int> _cntXY = SortQueue.front();
		SortQueue.pop();

		for (int i = 0; i < 4; i++) {
			int _Tx = _cntXY.first + DxDy[i][0];
			int _Ty = _cntXY.second + DxDy[i][1];

			if (_Tx >= _QSize || _Ty >= _QSize || _Tx < 0 || _Ty < 0)
				continue;

			if (_MAP[_Tx][_Ty] == 1) {
				_MAP[_Tx][_Ty] = _cntSort;
				SortQueue.push({ _Tx, _Ty });
				TotalPosQueue.push({ _Tx, _Ty });
			}

		}

	}

	return TotalPosQueue;
}


int FindShortBridge(queue<pair<unsigned char, unsigned char>>& TypeQueue, const int _cntType)
{
	int _shortLen = INT32_MAX;

	while (!TypeQueue.empty())
	{
		pair<int, int> _cntXY = TypeQueue.front();
		TypeQueue.pop();

		int _cnt;
		if (_MAP[_cntXY.first][_cntXY.second] == _cntType) _cnt = 0;
		else _cnt = _MAP[_cntXY.first][_cntXY.second];

		for (int i = 0; i < 4; i++) {
			int _Tx = _cntXY.first + DxDy[i][0];
			int _Ty = _cntXY.second + DxDy[i][1];

			if (_Tx >= _QSize || _Ty >= _QSize || _Tx < 0 || _Ty < 0 || _IsVisted[_Tx][_Ty])
				continue;

			if (_MAP[_Tx][_Ty] != _cntType && _MAP[_Tx][_Ty] >= 1) {
				if (_shortLen > -_cnt)
					_shortLen = -_cnt;
				break;
			}

			if (_MAP[_Tx][_Ty] == 0) {
				TypeQueue.push({ _Tx, _Ty });
				_IsVisted[_Tx][_Ty] = true;
				_MAP[_Tx][_Ty] = _cnt - 1;

			}
		}

	}

	return _shortLen;
}


int main()
{
	int _res = INT32_MAX;
	queue<queue<pair<unsigned char, unsigned char>>> TotalQueue;
	cin >> _QSize;
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++)
			cin >> _MAP[i][j];

	int _Sort = 2;
	for (int i = 0; i < _QSize; i++)
		for (int j = 0; j < _QSize; j++)
			if (_MAP[i][j] == 1) {
				TotalQueue.push(SortOutTypesIslands(_Sort, i, j));
				_Sort++;
			}

	while (!TotalQueue.empty())
	{
		queue<pair<unsigned char, unsigned char>> TypeQueue = TotalQueue.front();
		_Sort = _MAP[TypeQueue.front().first][TypeQueue.front().second];
		TotalQueue.pop();
		ClearMap();
		_res = min(_res, FindShortBridge(TypeQueue, _Sort));
	}

	cout << _res;

	return 0;
}

The post 백준 2146번 (다리 만들기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

영역 구하기

https://www.acmicpc.net/problem/2583

문제

눈금의 간격이 1인 M×N(M,N≤100)크기의 모눈종이가 있다.

이 모눈종이 위에 눈금에 맞추어 K개의 직사각형을 그릴 때,

이들 K개의 직사각형의 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어진다.

예를 들어 M=5, N=7 인 모눈종이 위에 <그림 1>과 같이 직사각형 3개를 그렸다면,

그 나머지 영역은 <그림 2>와 같이 3개의 분리된 영역으로 나누어지게 된다.

<그림 2>와 같이 분리된 세 영역의 넓이는 각각 1, 7, 13이 된다.

M, N과 K 그리고 K개의 직사각형의 좌표가 주어질 때,

K개의 직사각형 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어지는지,

그리고 분리된 각 영역의 넓이가 얼마인지를 구하여 이를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 M과 N, 그리고 K가 빈칸을 사이에 두고 차례로 주어진다.

M, N, K는 모두 100 이하의 자연수이다.

둘째 줄부터 K개의 줄에는 한 줄에 하나씩 직사각형의 왼쪽 아래 꼭짓점의 x, y좌표값과

오른쪽 위 꼭짓점의 x, y좌표값이 빈칸을 사이에 두고 차례로 주어진다.

모눈종이의 왼쪽 아래 꼭짓점의 좌표는 (0,0)이고, 오른쪽 위 꼭짓점의 좌표는(N,M)이다.

입력되는 K개의 직사각형들이 모눈종이 전체를 채우는 경우는 없다.

출력

첫째 줄에 분리되어 나누어지는 영역의 개수를 출력한다.

둘째 줄에는 각 영역의 넓이를 오름차순으로 정렬하여 빈칸을 사이에 두고 출력한다.

예제 입력 1

5 7 3
0 2 4 4
1 1 2 5
4 0 6 2

예제 출력 1

3
1 7 13

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2006 > 고등부 2번

• 문제의 오타를 찾은 사람: alphago92
• 데이터를 추가한 사람: hjhj97
• 잘못된 데이터를 찾은 사람: kookmin20103324

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 깊이 우선 탐색

통과된 코드

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>

using namespace std;

int _M, _N, _K, _DxDy[4][2] = {{1,0}, {-1,0}, {0, 1}, {0,-1}};
bool Table[100][100] = { false };
vector<int> ResVector;

int BFS(int _x, int _y)
{
	int _Area = 1;
	queue<pair<int, int>> BFSQueue;
	Table[_x][_y] = true;
	BFSQueue.push({_x, _y});
	while (!BFSQueue.empty()) {
		pair<int, int> _cnt = BFSQueue.front();
		BFSQueue.pop();
		for (int i = 0; i < 4; i++) {
			int _dx = _cnt.first + _DxDy[i][0];
			int _dy = _cnt.second + _DxDy[i][1];
			if (_dx < 0 || _dy < 0 || _dx >= _M|| _dy >= _N)
				continue;
			if (Table[_dx][_dy] == true)
				continue;
			BFSQueue.push({ _dx, _dy });
			Table[_dx][_dy] = true;
			_Area++;
		}
	}

	return _Area;
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> _M >> _N >> _K;

	for (int i = 0; i < _K; i++) {
		int _x1, _y1, _x2, _y2;
		cin >> _x1 >> _y1 >> _x2 >> _y2;
		for (int j = _x1; j < _x2; j++)
			for (int k = _y1; k < _y2; k++)
				Table[k][j] = true;
	}

	for (int i = 0; i < _M; i++)
		for (int j = 0; j < _N; j++) 
			if (Table[i][j] == false)
				ResVector.push_back(BFS(i, j));
	cout << ResVector.size() << "\n";
	sort(ResVector.begin(), ResVector.end());
	for (int i = 0; i < ResVector.size(); i++)
		cout << ResVector[i] << " ";
	return 0;
}

The post 백준 2583번 (영역 구하기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

치즈

https://www.acmicpc.net/problem/2636

문제

아래 <그림 1>과 같이 정사각형 칸들로 이루어진 사각형 모양의 판이 있고,

그 위에 얇은 치즈(회색으로 표시된 부분)가 놓여 있다.

판의 가장자리(<그림 1>에서 네모 칸에 X친 부분)에는 치즈가 놓여 있지 않으며 치즈에는 하나 이상의 구멍이 있을 수 있다.

이 치즈를 공기 중에 놓으면 녹게 되는데 공기와 접촉된 칸은 한 시간이 지나면 녹아 없어진다.

치즈의 구멍 속에는 공기가 없지만 구멍을 둘러싼 치즈가 녹아서 구멍이 열리면 구멍 속으로 공기가 들어가게 된다.

<그림 1>의 경우, 치즈의 구멍을 둘러싼 치즈는 녹지 않고 ‘c’로 표시된 부분만 한 시간 후에 녹아 없어져서 <그림 2>와 같이 된다.

다시 한 시간 후에는 <그림 2>에서 ‘c’로 표시된 부분이 녹아 없어져서 <그림 3>과 같이 된다.

<그림 3>은 원래 치즈의 두 시간 후 모양을 나타내고 있으며,

남은 조각들은 한 시간이 더 지나면 모두 녹아 없어진다.

그러므로 처음 치즈가 모두 녹아 없어지는 데는 세 시간이 걸린다.

<그림 3>과 같이 치즈가 녹는 과정에서 여러 조각으로 나누어 질 수도 있다.

입력으로 사각형 모양의 판의 크기와 한 조각의 치즈가 판 위에 주어졌을 때,

공기 중에서 치즈가 모두 녹아 없어지는 데 걸리는 시간과

모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 사각형 모양 판의 세로와 가로의 길이가 양의 정수로 주어진다.

세로와 가로의 길이는 최대 100이다.

판의 각 가로줄의 모양이 윗 줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

치즈가 없는 칸은 0, 치즈가 있는 칸은 1로 주어지며 각 숫자 사이에는 빈칸이 하나씩 있다.

출력

첫째 줄에는 치즈가 모두 녹아서 없어지는 데 걸리는 시간을 출력하고,

둘째 줄에는 모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 출력한다.

예제 입력 1

13 12
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0
0 1 1 1 0 0 0 1 1 0 0 0
0 1 1 1 1 1 1 0 0 0 0 0
0 1 1 1 1 1 0 1 1 0 0 0
0 1 1 1 1 0 0 1 1 0 0 0
0 0 1 1 0 0 0 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0

예제 출력 1

3
5

출처

Olympiad > 한국정보올림피아드 > KOI 2000 > 초등부 3번

• 문제의 오타를 찾은 사람: compro0317, shawn050912
• 데이터를 추가한 사람: jung2381187

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 시뮬레이션
• 너비 우선 탐색

통과된 코드

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
constexpr short MAX = 100;
short _N, _M, _Cheese = 0;
short _DxDy[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
bool _Map[MAX][MAX];
bool _IsVisted[MAX][MAX];
vector<short> Records;
vector<pair<short, short>> _Next;
queue<pair<short, short>> BFSqueue;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	bool _t;
	for (short i = 0; i < _N; i++)
		for (short j = 0; j < _M; j++) {
			cin >> _t;
			_Map[i][j] = _t;
			if (_t == 1)
				_Cheese++;
		}
	short _time = 0;
	while (true) {
		Records.push_back(_Cheese);
		if (_Cheese == 0)
			break;
		for (short i = 0; i < _N; i++)
			for (short j = 0; j < _M; j++)
				_IsVisted[i][j] = false;
		_Next.clear();
		BFSqueue.push({ 0,0 });
		_IsVisted[0][0] = true;
		while (!BFSqueue.empty()) {
			pair<short, short> _pos = BFSqueue.front();
			BFSqueue.pop();
			for (short i = 0; i < 4; i++) {
				short _dx = _pos.first + _DxDy[i][0];
				short _dy = _pos.second + _DxDy[i][1];

				if (_dx < 0 || _dy < 0 || _dx >= _N || _dy >= _M)
					continue;
				if (_IsVisted[_dx][_dy])
					continue;
				if (_Map[_dx][_dy] == 1) {
					_Next.push_back({ _dx, _dy });
					_IsVisted[_dx][_dy] = true;
					continue;
				}

				_IsVisted[_dx][_dy] = true;
				BFSqueue.push({ _dx, _dy});
			}
		}

		for (auto& it : _Next) {
			_Map[it.first][it.second] = 0;
			_Cheese--;
		}

		_time++;
	}

	cout << _time << "\n" << Records[Records.size() - 2];


	return 0;
}

The post 백준 2636번 (치즈, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

빙산

https://www.acmicpc.net/problem/2573

문제

지구 온난화로 인하여 북극의 빙산이 녹고 있다.

빙산을 그림 1과 같이 2차원 배열에 표시한다고 하자.

빙산의 각 부분별 높이 정보는 배열의 각 칸에 양의 정수로 저장된다.

빙산 이외의 바다에 해당되는 칸에는 0이 저장된다.

그림 1에서 빈칸은 모두 0으로 채워져 있다고 생각한다.

빙산의 높이는 바닷물에 많이 접해있는 부분에서 더 빨리 줄어들기 때문에,

배열에서 빙산의 각 부분에 해당되는 칸에 있는 높이는 일년마다 그 칸에 동서남북 네 방향으로 붙어있는 0이 저장된 칸의 개수만큼 줄어든다.

단, 각 칸에 저장된 높이는 0보다 더 줄어들지 않는다.

바닷물은 호수처럼 빙산에 둘러싸여 있을 수도 있다.

따라서 그림 1의 빙산은 일년후에 그림 2와 같이 변형된다.

그림 3은 그림 1의 빙산이 2년 후에 변한 모습을 보여준다.

2차원 배열에서 동서남북 방향으로 붙어있는 칸들은 서로 연결되어 있다고 말한다.

따라서 그림 2의 빙산은 한 덩어리이지만, 그림 3의 빙산은 세 덩어리로 분리되어 있다.

한 덩어리의 빙산이 주어질 때, 이 빙산이 두 덩어리 이상으로 분리되는 최초의 시간(년)을 구하는 프로그램을 작성하시오.

그림 1의 빙산에 대해서는 2가 답이다.

만일 전부 다 녹을 때까지 두 덩어리 이상으로 분리되지 않으면 프로그램은 0을 출력한다.

입력

첫 줄에는 이차원 배열의 행의 개수와 열의 개수를 나타내는 두 정수 N과 M이 한 개의 빈칸을 사이에 두고 주어진다.

N과 M은 3 이상 300 이하이다. 그 다음 N개의 줄에는 각 줄마다 배열의 각 행을 나타내는 M개의 정수가 한 개의 빈 칸을 사이에 두고 주어진다.

각 칸에 들어가는 값은 0 이상 10 이하이다.

배열에서 빙산이 차지하는 칸의 개수, 즉, 1 이상의 정수가 들어가는 칸의 개수는 10,000 개 이하이다.

배열의 첫 번째 행과 열, 마지막 행과 열에는 항상 0으로 채워진다.

출력

첫 줄에 빙산이 분리되는 최초의 시간(년)을 출력한다.

만일 빙산이 다 녹을 때까지 분리되지 않으면 0을 출력한다.

예제 입력 1

5 7
0 0 0 0 0 0 0
0 2 4 5 3 0 0
0 3 0 2 5 2 0
0 7 6 2 4 0 0
0 0 0 0 0 0 0

예제 출력 1

2

예제 입력 A

5 7
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 1 0 0 0 0 
0 0 0 0 0 0 0
0 0 0 0 0 0 0

예제 출력 A

0

예제 입력 B

7 7
0 0 0 0 0 0 0
0 1 1 0 1 1 0
0 1 9 1 9 1 0
0 1 1 1 1 1 0
0 1 1 1 1 1 0
0 0 1 1 1 0 0
0 0 0 0 0 0 0

예제 출력 B

2

출처

Olympiad > 한국정보올림피아드 > KOI 2006 > 초등부 2번

• 잘못된 데이터를 찾은 사람: occidere, zayne

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 깊이 우선 탐색

통과된 코드

#include <iostream>
#include <queue>
using namespace std;
constexpr short MAX = 300;
short _MAP[2][MAX][MAX];
bool _IsVisted[MAX][MAX];
short _N, _M, _Res = 0, _Glaciers = 0, _Cluster = 0;
short _DxDy[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };

void BFS(short _i, short _j)
{
	queue<pair<short, short>> BFSQueue;
	BFSQueue.push({ _i, _j });
	while (!BFSQueue.empty()) {
		pair<short, short> _CntPos = BFSQueue.front();
		BFSQueue.pop();
		short _Sea = 0;
		for (short i = 0; i < 4; i++) {
			short _dx = _CntPos.first + _DxDy[i][0];
			short _dy = _CntPos.second + _DxDy[i][1];
			if (_dx < 0 || _dy < 0 || _dx >= _N || _dy >= _M)
				continue;
			if (_MAP[0][_dx][_dy] <= 0) {
				_Sea++;
				continue;
			}
			if (_IsVisted[_dx][_dy])
				continue;
			_IsVisted[_dx][_dy] = true;
			BFSQueue.push({ _dx, _dy });
		}
		_MAP[1][_CntPos.first][_CntPos.second] = _Sea;
	}
}


short ClusterCount()
{
	short _cnt = 0;
	for (short i = 0; i < _N; i++)
		for (short j = 0; j < _M; j++)
			_IsVisted[i][j] = false;
	for (short i = 0; i < _N; i++)
		for (short j = 0; j < _M; j++) {
			if (_MAP[0][i][j] <= 0 || _IsVisted[i][j])
				continue;
			BFS(i, j);
			_cnt++;
		}
	return _cnt;
}


int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	short _Temp;
	for (short i = 0; i < _N; i++)
		for (short j = 0; j < _M; j++) {
			cin >> _Temp;
			if (_Temp > 0)
				_Glaciers++;
			_MAP[0][i][j] = _Temp;
		}
	short _Cnt = 0;
	while (true) {
		_Cluster = ClusterCount();
		if (_Cluster >= 2 ) {
			_Res = _Cnt;
			break;
		}
		if (_Glaciers <= 1) {
			_Res = 0; 
			break;
		}

		for (short i = 0; i < _N; i++)
			for (short j = 0; j < _M; j++) {
				if (_MAP[0][i][j] <= 0)
					continue;
				_MAP[0][i][j] -= _MAP[1][i][j];
				if (_MAP[0][i][j] <= 0)
					_Glaciers--;
			}
		_Cnt++;
	}

	cout << _Res;

	return 0;
}

The post 백준 2573번 (빙산, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

나이트의 이동

https://www.acmicpc.net/problem/7562

문제

체스판 위에 한 나이트가 놓여져 있다.

나이트가 한 번에 이동할 수 있는 칸은 아래 그림에 나와있다.

나이트가 이동하려고 하는 칸이 주어진다.

나이트는 몇 번 움직이면 이 칸으로 이동할 수 있을까?

입력

입력의 첫째 줄에는 테스트 케이스의 개수가 주어진다.

각 테스트 케이스는 세 줄로 이루어져 있다.

첫째 줄에는 체스판의 한 변의 길이 l(4 ≤ l ≤ 300)이 주어진다.

체스판의 크기는 l × l이다. 체스판의 각 칸은 두 수의 쌍 {0, …, l-1} × {0, …, l-1}로 나타낼 수 있다.

둘째 줄과 셋째 줄에는 나이트가 현재 있는 칸, 나이트가 이동하려고 하는 칸이 주어진다.

출력

각 테스트 케이스마다 나이트가 최소 몇 번만에 이동할 수 있는지 출력한다.

예제 입력 1

5
1 3 2 -1
2 4 4 -1
3 1 2 4 3 -1
4 2 4 3 3 5 6 -1
5 4 6 -1

예제 출력 1

11

출처

University > Tu-Darmstadt Programming Contest > TUD Contest 2001 3번

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: sait2000
• 문제의 오타를 찾은 사람: sgchoi5

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색

통과된 코드

#include <iostream>
#include <queue>

using namespace std;

constexpr int MAX = 300;

int _T, _I, _Res = 0;
int _DxDy[8][2] = { {-2,-1},{-2,1}, {2, 1}, {2, -1}, {1, 2}, {1, -2}, {-1, 2}, {-1, -2} };
bool _IsVisted[MAX][MAX];
pair<int, int> Pos[2];

struct CntPos
{
	int _Cnt = 0;
	pair<int, int> _CntPos = {0, 0};

	CntPos(int _cnt, pair<int, int> _cntPos) : _Cnt(_cnt), _CntPos(_cntPos) {};
};

queue<CntPos> BFSQueue;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	
	cin >> _T;
	while (_T--)
	{
		cin >> _I;
		for (int i = 0; i < _I; i++)
			for (int j = 0; j < _I; j++)
				_IsVisted[i][j] = false;
			
		int _x, _y;
		for (int i = 0; i < 2; i++) {
			cin >> _x >> _y;
			Pos[i].first = _x;
			Pos[i].second = _y;
		}

		while (!BFSQueue.empty())
			BFSQueue.pop();
		
		BFSQueue.push(CntPos(0, Pos[0]));
		_IsVisted[Pos[0].first][Pos[0].second] = true;
		while (!BFSQueue.empty()) {
			Pos[0] = BFSQueue.front()._CntPos;
			int _cnt = BFSQueue.front()._Cnt;
			BFSQueue.pop();
			if (Pos[0] == Pos[1]) {
				_Res = _cnt;
				break;
			}

			for (int i = 0; i < 8; i++) {
				int _dx = Pos[0].first + _DxDy[i][0];
				int _dy = Pos[0].second + _DxDy[i][1];
				if (_dx < 0 || _dy < 0 || _dx >= _I || _dy >= _I)
					continue;
				if (_IsVisted[_dx][_dy]) 
					continue;
				BFSQueue.push(CntPos(_cnt + 1, { _dx, _dy }));
				_IsVisted[_dx][_dy] = true;
			}
		}

		cout <<_Res << "\n";
	}

	return 0;
}

The post 백준 7562번 (나이트의 이동, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

두 동전

https://www.acmicpc.net/problem/16197

문제

N×M 크기의 보드와 4개의 버튼으로 이루어진 게임이 있다.

보드는 1×1크기의 정사각형 칸으로 나누어져 있고, 각각의 칸은 비어있거나, 벽이다.

두 개의 빈 칸에는 동전이 하나씩 놓여져 있고, 두 동전의 위치는 다르다.

버튼은 “왼쪽”, “오른쪽”, “위”, “아래”와 같이 4가지가 있다.

버튼을 누르면 두 동전이 버튼에 쓰여 있는 방향으로 동시에 이동하게 된다.

• 동전이 이동하려는 칸이 벽이면, 동전은 이동하지 않는다.
• 동전이 이동하려는 방향에 칸이 없으면 동전은 보드 바깥으로 떨어진다.
• 그 외의 경우에는 이동하려는 방향으로 한 칸 이동한다.이동하려는 칸에 동전이 있는 경우에도 한 칸 이동한다.

두 동전 중 하나만 보드에서 떨어뜨리기 위해 버튼을 최소 몇 번 눌러야하는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 보드의 세로 크기 N과 가로 크기 M이 주어진다. (1 ≤ N, M ≤ 20)

둘째 줄부터 N개의 줄에는 보드의 상태가 주어진다.

• o: 동전
• .: 빈 칸
• #: 벽

동전의 개수는 항상 2개이다.

출력

첫째 줄에 두 동전 중 하나만 보드에서 떨어뜨리기 위해 눌러야 하는 버튼의 최소 횟수를 출력한다.

만약, 두 동전을 떨어뜨릴 수 없거나, 버튼을 10번보다 많이 눌러야 한다면, -1을 출력한다.

예제 입력 1

1 2
oo

예제 출력 1

1

예제 입력 2

6 2
.#
.#
.#
o#
o#
##

예제 출력 2

3

예제 입력 3

6 2
..
..
..
o#
o#
##

예제 출력 3

3

예제 입력 4

5 3
###
.o.
###
.o.
###

예제 출력 4

-1

예제 입력 5

5 3
###
.o.
#.#
.o.
###

예제 출력 5

3

출처

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 백트래킹

통과된 코드

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int _N, _M, _Res = -1;
int _DxDy[4][2] = { { 1, 0}, { 0, -1}, { 0, 1}, { -1, 0} };
char _Map[20][20];
string _Str;

vector<pair<int,int>> _Coins;

struct CntPos
{
	pair<int,int> CoinOne;
	pair<int,int> CoinTwo;
	int Cnt;

	CntPos(int _x1, int _y1, int _x2, int _y2, int _cnt) 
		: CoinOne(make_pair(_x1, _y1)), CoinTwo(make_pair(_x2, _y2)), Cnt(_cnt) {}
};

queue<CntPos> BfsQueue;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	for (int i = 0; i < _N; i++) {
		cin >> _Str;
		for (int j = 0; j < _M; j++) {
			_Map[i][j] = _Str[j];
			if (_Str[j] == 'o')
				_Coins.push_back({ i, j });
		}
	}

	BfsQueue.push(CntPos(_Coins[0].first, _Coins[0].second, _Coins[1].first, _Coins[1].second, 0));
	while (!BfsQueue.empty()) {
		CntPos _cntpos = BfsQueue.front();
		BfsQueue.pop();

		for (int i = 0; i < 4; i++) {
			bool CheckOne = false, CheckTwo = false;
			_Coins[0].first = _cntpos.CoinOne.first + _DxDy[i][0];
			_Coins[0].second = _cntpos.CoinOne.second + _DxDy[i][1];
			_Coins[1].first = _cntpos.CoinTwo.first + _DxDy[i][0];
			_Coins[1].second = _cntpos.CoinTwo.second + _DxDy[i][1];

			// 동전의 위치가 같다면 하나만 떨어뜨리는 조건에 맞지 않는다.
			if (_Coins[0] == _Coins[1]) continue;

			// 두 동전 중 하나만 보드에서 떨어뜨리기 위함
			if (_Coins[0].first < 0 || _Coins[0].second < 0 || _Coins[0].first >= _N || _Coins[0].second >= _M)
				CheckOne = true;
			if (_Coins[1].first < 0 || _Coins[1].second < 0 || _Coins[1].first >= _N || _Coins[1].second >= _M)
				CheckTwo = true;

			// 동전이 이동하려는 칸이 벽이면, 동전은 이동하지 않는다.
			if (!CheckOne && (_Map[_Coins[0].first][_Coins[0].second] == '#')) {
				_Coins[0].first = _cntpos.CoinOne.first;
				_Coins[0].second = _cntpos.CoinOne.second;
			}
			if (!(CheckTwo) && _Map[_Coins[1].first][_Coins[1].second] == '#') {
				_Coins[1].first = _cntpos.CoinTwo.first;
				_Coins[1].second = _cntpos.CoinTwo.second;
			}

			int _TCnt = _cntpos.Cnt;
			if (_TCnt >= 10) {
				_Res = -1;
				while (!BfsQueue.empty())
					BfsQueue.pop();
				break;
			}

			if (CheckOne ^ CheckTwo) {
				_Res = _TCnt + 1;
				while (!BfsQueue.empty())
					BfsQueue.pop();
				break;
			}
			else if(CheckOne && CheckTwo)
				continue;

			BfsQueue.push(CntPos(_Coins[0].first, _Coins[0].second, _Coins[1].first, _Coins[1].second, _TCnt + 1));
		}
	}

	cout << _Res;
	return 0;
}

생각보다 메모리를 많이 사용…

DFS 탐색을 이용한 백트레킹 방법이 시간과 메모리 부분에서 더 효율적이다.

DFS 참고 코드

https://hyeo-noo.tistory.com/126

#include <iostream>
#include <queue>
#include <cstring>
 
#define pii pair<int, int>
 
using namespace std;
 
 
int N, M, result = 1e9+7;
int Map[21][21];    // 2 : 동전 위치   0 : 벽 위치   1 : 빈칸
vector< pii > startP;
int dr[4] = {0, 0, 1, -1}, dc[4] = {1, -1, 0, 0};
 
void input(){
    // Map에서 벗어나는 경우는 -1로 설정
    memset(Map, -1, sizeof(Map));
    
    cin >> N >> M;
    string str;
    for(int i = 1; i <= N; i++){
        cin >> str;
        for(int j = 0; j < M; j++){
            if(str[j] == 'o'){
                Map[i][j+1] = 2;
                startP.push_back({i, j+1});
            }
            else if(str[j] == '#') Map[i][j+1] = 0;
            else Map[i][j+1] = 1;
        }
    }
}
 
bool isOut(const pii &A){
    if(A.first < 1 || A.first > N || A.second < 1 || A.second > M) return true;
    return false;
}
 
void dfs(pii A, pii B, int cnt){
    // 현재 result보다 cnt가 크다면 더이상의 탐색은 불필요
    if(result < cnt) return;
    
    // cnt 가 10보다 커지면 result값 갱신
    if(cnt > 10){
        result = min(result, cnt);
        return;
    }
    
    // 둘 다 떨어졌으면 되돌아감
    if(isOut(A) && isOut(B)) return;
    // 하나만 떨어졌으면 result를 최소 cnt값으로 교체
    else if((isOut(A) && !isOut(B)) || (!isOut(A) && isOut(B))){
        result = min(result, cnt);
        return;
    }
    
    for(int i = 0; i < 4; i++){
        pii An = {A.first + dr[i], A.second + dc[i]};
        pii Bn = {B.first + dr[i], B.second + dc[i]};
        if(!Map[An.first][An.second]) An = A;
        if(!Map[Bn.first][Bn.second]) Bn = B;
        
        dfs(An, Bn, cnt+1);
    }
}
 
int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    
    input();
    dfs(startP[0], startP[1], 0);
    
    if(result > 10) cout << -1;
    else cout << result;
    
    return 0;
}

The post 백준 16197번 (두 동전, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

탈옥

https://www.acmicpc.net/problem/9376

문제

상근이는 감옥에서 죄수 두 명을 탈옥시켜야 한다.

이 감옥은 1층짜리 건물이고, 상근이는 방금 평면도를 얻었다.

평면도에는 모든 벽과 문이 나타나있고, 탈옥시켜야 하는 죄수의 위치도 나타나 있다.

감옥은 무인 감옥으로 죄수 두 명이 감옥에 있는 유일한 사람이다.

문은 중앙 제어실에서만 열 수 있다.

상근이는 특별한 기술을 이용해 제어실을 통하지 않고 문을 열려고 한다.

하지만, 문을 열려면 시간이 매우 많이 걸린다.

두 죄수를 탈옥시키기 위해서 열어야 하는 문의 개수를 구하는 프로그램을 작성하시오.

문을 한 번 열면 계속 열린 상태로 있는다.

입력

첫째 줄에 테스트 케이스의 개수가 주어진다.

테스트 케이스의 수는 100개를 넘지 않는다.

첫째 줄에는 평면도의 높이 h와 너비 w가 주어진다. (2 ≤ h, w ≤ 100)

다음 h개 줄에는 감옥의 평면도 정보가 주어지며,

빈 공간은 ‘.’, 지나갈 수 없는 벽은 ‘*’, 문은 ‘#’, 죄수의 위치는 ‘$’이다.

상근이는 감옥 밖을 자유롭게 이동할 수 있고, 평면도에 표시된 죄수의 수는 항상 두 명이다.

각 죄수와 감옥의 바깥을 연결하는 경로가 항상 존재하는 경우만 입력으로 주어진다.

출력

각 테스트 케이스마다 두 죄수를 탈옥시키기 위해서 열어야 하는 문의 최솟값을 출력한다.

예제 입력 1

3
5 9
****#****
*..#.#..*
****.****
*$#.#.#$*
*********
5 11
*#*********
*$*...*...*
*$*.*.*.*.*
*...*...*.*
*********.*
9 9
*#**#**#*
*#**#**#*
*#**#**#*
*#**.**#*
*#*#.#*#*
*$##*##$*
*#*****#*
*.#.#.#.*
*********

예제 출력 1

4
0
9

출처

ICPC > Regionals > Europe > Northwestern European Regional Contest > Benelux Algorithm Programming Contest > BAPC 2013 J번

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: doju, playsworld16, yukino

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 데이크스트라
• 0-1 너비 우선 탐색

통과된 코드

#include <iostream>
#include <vector>
#include <queue>

constexpr int MAX = 102;
using namespace std;

int _T, _H, _W;
int _DxDy[4][2] = { { 1, 0}, { 0, -1}, { 0, 1}, { -1, 0} };

vector<pair<int, int>> _Theifs;

char _Map[MAX][MAX];
int _IsVisted[3][MAX][MAX];

struct Pos
{
	int _X, _Y, _Doors;
	Pos(int _x, int _y, int _doors) : _X(_x), _Y(_y), _Doors(_doors) {};
	bool operator<(const Pos& other) const {
		return _Doors > other._Doors;
	}
};

void BFSFuction(int _x, int _y, int _n)
{
	for (int i = 0; i < MAX; i++)
		for (int j = 0; j < MAX; j++)
			_IsVisted[_n][i][j] = INT32_MAX;
	priority_queue<Pos> _BFSQueue;
	_BFSQueue.push(Pos(_x, _y, 0));
	_IsVisted[_n][_x][_y] = 0;
	while (!_BFSQueue.empty()) {
		int CntX = _BFSQueue.top()._X;
		int CntY = _BFSQueue.top()._Y;
		int Doors = _BFSQueue.top()._Doors;
		_BFSQueue.pop();
		if (_IsVisted[_n][CntX][CntY] < Doors)
			continue;
		for (int i = 0; i < 4; i++) {
			int dx = CntX + _DxDy[i][0];
			int dy = CntY + _DxDy[i][1];
			int doors = Doors;
			if (dx == -1 || dy == -1 || dx == _H + 2 || dy == _W + 2)
				continue;
			if (_Map[dx][dy] == '*')
				continue;
			else if (_Map[dx][dy] == '#')
				doors++;
			if (doors < _IsVisted[_n][dx][dy]) {
				_BFSQueue.push(Pos(dx, dy, doors));
				_IsVisted[_n][dx][dy] = doors;
			}
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _T;
	while (_T--) {
		cin >> _H >> _W;
		_Theifs.clear();
		for (int i = 0; i < MAX; i++)
			for (int j = 0; j < MAX; j++)
				_Map[i][j] = ' ';
		for (int i = 1; i <= _H; i++) {
			string _Str;
			cin >> _Str;
			for (int j = 0; j < _W; j++) {
				_Map[i][j + 1] = _Str[j];
				if (_Str[j] == '$')
					_Theifs.push_back({ i, j + 1 });
			}
		}
		BFSFuction(_Theifs[0].first, _Theifs[0].second, 0);
		BFSFuction(_Theifs[1].first, _Theifs[1].second, 1);
		BFSFuction(0, 0, 2);
		int _Res = INT32_MAX;
		for (int i = 0; i <= _H + 1; i++)
			for (int j = 0; j <= _W + 1; j++) {
				if (_Map[i][j] == '*') continue;
				if (_IsVisted[0][i][j] == INT32_MAX || _IsVisted[1][i][j] == INT32_MAX || _IsVisted[2][i][j] == INT32_MAX)
					continue;
				int _sum = _IsVisted[0][i][j] + _IsVisted[1][i][j] + _IsVisted[2][i][j];
				if (_Map[i][j] == '#')
					_sum -= 2;
				_Res = min(_Res, _sum);
			}
		cout << _Res << "\n";
	}

	return 0;
}

The post 백준 9376번 (탈옥, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

벽 부수고 이동하기 2

https://www.acmicpc.net/problem/14442

문제

N×M의 행렬로 표현되는 맵이 있다.

맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다.

당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다.

최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데, 이때 시작하는 칸과 끝나는 칸도 포함해서 센다.

만약에 이동하는 도중에 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 K개 까지 부수고 이동하여도 된다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000), K(1 ≤ K ≤ 10)이 주어진다.

다음 N개의 줄에 M개의 숫자로 맵이 주어진다.

(1, 1)과 (N, M)은 항상 0이라고 가정하자.

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

예제 입력 1

6 4 1
0100
1110
1000
0000
0111
0000

예제 출력 1

15

예제 입력 2

6 4 2
0100
1110
1000
0000
0111
0000

예제 출력 2

9

예제 입력 3

4 4 3
0111
1111
1111
1110

예제 출력 3

-1

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: jh05013, sait2000, YunGoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색

통과된 코드

#include <iostream>
#include <queue>
using namespace std;
bool _Map[1000][1000];
bool _IsVisted[11][1000][1000];
int _N, _M, _K, _Res = INT32_MAX;
string _Temp;
int _DxDy[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
queue<pair<int, pair<int, pair<int, int>>>> _BFSQueue;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M >> _K;
	for (int i = 0; i < _N; i++) {
		cin >> _Temp;
		for (int j = 0; j < _M; j++)
			if (_Temp[j] == '1')
				_Map[i][j] = true;
	}
	_BFSQueue.push(make_pair(0, make_pair(0, make_pair(0, 0))));
	_IsVisted[0][0][0] = true;
	while (!_BFSQueue.empty()) {
		int _Cnt = _BFSQueue.front().first;
		int _k = _BFSQueue.front().second.first;
		pair<int, int> _Pos = _BFSQueue.front().second.second;
		_BFSQueue.pop();
		if (_Pos.first == _N - 1 && _Pos.second == _M - 1) {
			_Res = _Cnt + 1;
			break;
		}

		for (int i = 0; i < 4; i++) {
			int _dx = _Pos.first + _DxDy[i][0];
			int _dy = _Pos.second + _DxDy[i][1];
			if (_dx >= _N || _dy >= _M || _dx < 0 || _dy < 0)
				continue;
			if (_Map[_dx][_dy] && _k < _K && !_IsVisted[_k + 1][_dx][_dy]) {
				_IsVisted[_k + 1][_dx][_dy] = true;
				_BFSQueue.push(make_pair(_Cnt + 1, make_pair(_k + 1, make_pair(_dx, _dy))));
			}
			if (!_Map[_dx][_dy] &&  !_IsVisted[_k][_dx][_dy]) {
				_IsVisted[_k][_dx][_dy] = true;
				_BFSQueue.push(make_pair(_Cnt + 1, make_pair(_k, make_pair(_dx, _dy))));
			}
		}
	}
	if (_Res == INT32_MAX) cout << -1;
	else cout << _Res;
	return 0;
}

The post 백준 14442번 (벽 부수고 이동하기 2, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

미로만들기

https://www.acmicpc.net/problem/2665

문제

n×n 바둑판 모양으로 총 n²개의 방이 있다.

일부분은 검은 방이고 나머지는 모두 흰 방이다.

검은 방은 사면이 벽으로 싸여 있어 들어갈 수 없다.

서로 붙어 있는 두 개의 흰 방 사이에는 문이 있어서 지나다닐 수 있다.

윗줄 맨 왼쪽 방은 시작방으로서 항상 흰 방이고, 아랫줄 맨 오른쪽 방은 끝방으로서 역시 흰 방이다.

시작방에서 출발하여 길을 찾아서 끝방으로 가는 것이 목적인데, 아래 그림의 경우에는 시작방에서 끝 방으로 갈 수가 없다.

부득이 검은 방 몇 개를 흰 방으로 바꾸어야 하는데 되도록 적은 수의 방의 색을 바꾸고 싶다.

아래 그림은 n=8인 경우의 한 예이다.

위 그림에서는 두 개의 검은 방(예를 들어 (4,4)의 방과 (7,8)의 방)을 흰 방으로 바꾸면,

시작방에서 끝방으로 갈 수 있지만, 어느 검은 방 하나만을 흰 방으로 바꾸어서는 불가능하다.

검은 방에서 흰 방으로 바꾸어야 할 최소의 수를 구하는 프로그램을 작성하시오.

단, 검은 방을 하나도 흰방으로 바꾸지 않아도 되는 경우는 0이 답이다.

입력

첫 줄에는 한 줄에 들어가는 방의 수 n(1 ≤ n ≤ 50)이 주어지고,

다음 n개의 줄의 각 줄마다 0과 1이 이루어진 길이가 n인 수열이 주어진다.

0은 검은 방, 1은 흰 방을 나타낸다.

출력

첫 줄에 흰 방으로 바꾸어야 할 최소의 검은 방의 수를 출력한다.

예제 입력 1

8
11100110
11010010
10011010
11101100
01000111
00110001
11011000
11000111

예제 출력 1

2

출처

Olympiad > 한국정보올림피아드 > KOI 1997 > 고등부 2번

• 문제의 오타를 찾은 사람: silvercube
• 데이터를 추가한 사람: yukariko

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 데이크스트라
• 0-1 너비 우선 탐색

통과된 코드

우선 순위 Queue를 이용하여 방을 바꾸는 순서가 적은 순으로 탐색합니다.

#include <iostream>
#include <queue>
using namespace std;
int _N, _Res;
int _DxDy[4][2] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };;
string _Str;
bool _Map[50][50];
bool _IsVisted[50][50];
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, greater<pair<int, pair<int, int>>>> _BfsQueue;
int main()
{
	cin >> _N;
	for (int i = 0; i < _N; i++) {
		cin >> _Str;
		for (int j = 0; j < _N; j++)
			if (_Str[j] == '1')
				_Map[i][j] = true;		
	}

	_BfsQueue.push(make_pair(0, make_pair(0, 0)));
	_IsVisted[0][0] = true;
	while (!_BfsQueue.empty()) {
		pair<int, int> _Pos = _BfsQueue.top().second;
		int _Cnt = _BfsQueue.top().first;
		_BfsQueue.pop();
		if (_Pos.first == _N - 1 && _Pos.second == _N - 1) {
			_Res = _Cnt;
			break;
		}
		for (int i = 0; i < 4; i++) {
			int _dx = _Pos.first + _DxDy[i][0];
			int _dy = _Pos.second + _DxDy[i][1];
			if (_dx >= _N || _dy >= _N || _dx < 0 || _dy < 0)
				continue;
			if (_IsVisted[_dx][_dy]) continue;
			_IsVisted[_dx][_dy] = true;
			if (!_Map[_dx][_dy]) _BfsQueue.push(make_pair(_Cnt + 1, make_pair(_dx, _dy)));
			else _BfsQueue.push(make_pair(_Cnt, make_pair(_dx, _dy)));
		}
	}

	cout << _Res;

	return 0;
}

The post 백준 2665번 (미로만들기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

배열에서 이동

https://www.acmicpc.net/problem/1981

문제

n×n짜리의 배열이 하나 있다. 이 배열의 (1, 1)에서 (n, n)까지 이동하려고 한다.

이동할 때는 상, 하, 좌, 우의 네 인접한 칸으로만 이동할 수 있다.

이와 같이 이동하다 보면, 배열에서 몇 개의 수를 거쳐서 이동하게 된다.

이동하기 위해 거쳐 간 수들 중 최댓값과 최솟값의 차이가 가장 작아지는 경우를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n(2 ≤ n ≤ 100)이 주어진다.

다음 n개의 줄에는 배열이 주어진다.

배열의 각 수는 0보다 크거나 같고, 200보다 작거나 같은 정수이다.

출력

첫째 줄에 (최대 – 최소)가 가장 작아질 때의 그 값을 출력한다.

예제 입력 1

5
1 1 3 6 8
1 2 2 5 5
4 4 0 3 3
8 0 2 3 4
4 3 0 2 1

예제 출력 1

2

출처

University > Tu-Darmstadt Programming Contest > TUD Contest 2006 6번

Olympiad > USA Computing Olympiad > 2002-2003 Season > USACO US Open 2003 Contest > Green 1번

• 문제를 번역한 사람: author5
• 데이터를 추가한 사람: kdk8361, yclock

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 이분 탐색
• 너비 우선 탐색

통과된 코드

범위를 확인할 때 이분탐색을 이용하여 시간 복잡도를 낮추어야 한다.

#include <iostream>
#include <queue>
using namespace std;

int _N, _Res = 1000;
int _inMax = -INT32_MAX, _inMin = INT32_MAX;
int _DxDy[4][2] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
int _Map[101][101], _IsVisted[101][101];
int _End, _Start, _Mid;

queue<pair<int, int>> _BFSQueue;

bool BFS(int _Dif)
{
	for (int i = _inMin; i <= _inMax; i++) {
		for (int j = 1; j <= _N; j++)
			for (int k = 1; k <= _N; k++)
				_IsVisted[j][k] = true;

		// 해당 범위에 속한다면 방문체크  해제(탐색을 위함)  
		for (int j = 1; j <= _N; j++)
			for (int k = 1; k <= _N; k++)
				if (i <= _Map[j][k] && _Map[j][k] <= i + _Dif)
					_IsVisted[j][k] = false;
		// 도착지점이 성립할 수 없는 경우
		if (i > _Map[_N][_N] || _Map[_N][_N] > i + _Dif) 
			continue;
		while (!_BFSQueue.empty())
			_BFSQueue.pop();
		_BFSQueue.push(make_pair(1, 1));
		while (!_BFSQueue.empty()) {
			pair<int, int> _Pos = _BFSQueue.front();
			_BFSQueue.pop();
			if (_IsVisted[_Pos.first][_Pos.second]) continue;
			_IsVisted[_Pos.first][_Pos.second] = true;
			if (_Pos.first == _N && _Pos.second == _N)
				return true;
			int _dx, _dy;
			for (int i = 0; i < 4; i++) {
				_dx = _Pos.first + _DxDy[i][0];
				_dy = _Pos.second + _DxDy[i][1];
				if (_dx > _N || _dy > _N || _dx <= 0 || _dy <= 0) continue;
				_BFSQueue.push(make_pair(_dx, _dy));
			}
		}
	}

	return false;
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N;
	int _in;
	for (int i = 1; i <= _N; i++)
		for (int j = 1; j <= _N; j++) {
			cin >> _in;
			_Map[i][j] = _in;
			_inMax = max(_in, _inMax);
			_inMin = min(_in, _inMin);
		}

	_End = _inMax - _inMin;
	_Start = 0;
	while (_Start <= _End) {
		_Mid = (_End + _Start) / 2;
		if (BFS(_Mid)) _End = _Mid - 1;
		else _Start = _Mid + 1;
	}
	cout << _End + 1;
	return 0;
}

The post 백준 1981번 (배열에서 이동, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.