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

문제

정수 A를 B로 바꾸려고 한다. 가능한 연산은 다음과 같은 두 가지이다.

• 2를 곱한다.
• 1을 수의 가장 오른쪽에 추가한다. 

A를 B로 바꾸는데 필요한 연산의 최솟값을 구해보자.

입력

첫째 줄에 A, B (1 ≤ A < B ≤ 10⁹)가 주어진다.

출력

A를 B로 바꾸는데 필요한 연산의 최솟값에 1을 더한 값을 출력한다.

만들 수 없는 경우에는 -1을 출력한다.

예제 입/출력 1

2 162

5

2 → 4 → 8 → 81 → 162

예제 입/출력 2

4 42

-1

2 → 4 → 8 → 81 → 162

예제 입/출력 3

100 40021

5

100 → 200 → 2001 → 4002 → 40021

출처

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 그래프 이론
• 그리디 알고리즘
• 그래프 탐색
• 너비 우선 탐색

통과된 코드

DFS(재귀)를 이용하여 해결

재귀를 수행하면서 조건을 만족할 수 없다면 Return

#include <iostream>
using namespace std;

int MinRes = INT16_MAX;
long long int Target = 0;

void Recursion(int _depth, long long int _val) {
    // 목표 값보다 크면 반환
    if (_val > Target)
        return;

    // 현재 깊이가 최소값보다 크면 반환
    if (_depth > MinRes)
        return;

    // 목표 값에 도달하면 최소 깊이 갱신
    if (Target == _val) {
        MinRes = min(MinRes, _depth);
        return;
    }

    // 재귀 호출을 통해 2를 곱하거나 1을 추가
    Recursion(_depth + 1, _val * 2);
    Recursion(_depth + 1, (_val * 10) + 1);
}

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

    long long int Start = 0;
    cin >> Start >> Target;
    
    // 초기 깊이는 1로 설정
    Recursion(1, Start);
    
    // 결과 출력: 만들 수 없는 경우 -1 출력
    if (INT16_MAX == MinRes)
        cout << -1;
    else
        cout << MinRes;
}

int => long long int

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

다리 만들기

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/5639

문제

이진 검색 트리는 다음과 같은 세 가지 조건을 만족하는 이진 트리이다.

• 노드의 왼쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 작다.
• 노드의 오른쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 크다.
• 왼쪽, 오른쪽 서브트리도 이진 검색 트리이다.

전위 순회 (루트-왼쪽-오른쪽)은 루트를 방문하고, 왼쪽 서브트리, 오른쪽 서브 트리를 순서대로 방문하면서 노드의 키를 출력한다.

후위 순회 (왼쪽-오른쪽-루트)는 왼쪽 서브트리, 오른쪽 서브트리, 루트 노드 순서대로 키를 출력한다.

예를 들어, 위의 이진 검색 트리의 전위 순회 결과는 50 30 24 5 28 45 98 52 60 이고, 후위 순회 결과는 5 28 24 45 30 60 52 98 50 이다.

이진 검색 트리를 전위 순회한 결과가 주어졌을 때, 이 트리를 후위 순회한 결과를 구하는 프로그램을 작성하시오.

입력

트리를 전위 순회한 결과가 주어진다.

노드에 들어있는 키의 값은 10⁶보다 작은 양의 정수이다.

모든 값은 한 줄에 하나씩 주어지며, 노드의 수는 10,000개 이하이다.

같은 키를 가지는 노드는 없다.

출력

입력으로 주어진 이진 검색 트리를 후위 순회한 결과를 한 줄에 하나씩 출력한다.

예제 입력 1

50
30
24
5
28
45
98
52
60

예제 출력 1

5
28
24
45
30
60
52
98
50

출처

ICPC > Regionals > Asia Pacific > Thailand > 2011 ACM-ICPC Asia Phuket Regional Programming Contest B번

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 재귀

통과된 코드

#include <iostream>

using namespace std;

struct BinaryNode
{
    int _Num;
    BinaryNode* _Left;
    BinaryNode* _Right;

    BinaryNode(int num)
        : _Num(num), _Left(nullptr), _Right(nullptr)
    {}

    void ArrayBinaryNode(int _n)
    {
        if (_Num > _n) {
            if (_Left == nullptr) _Left = new BinaryNode(_n);
            else _Left->ArrayBinaryNode(_n);
        }
        else {
            if (_Right == nullptr) _Right = new BinaryNode(_n);
            else _Right->ArrayBinaryNode(_n);
        }
    }
};

void PostorderTraverse(BinaryNode& CurrentNode)
{
    if (CurrentNode._Left != nullptr) PostorderTraverse(*CurrentNode._Left);
    if (CurrentNode._Right != nullptr) PostorderTraverse(*CurrentNode._Right);
    cout << CurrentNode._Num << "\n";
}


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

    int _N;
    cin >> _N;
    BinaryNode _RootNode(_N);
    while (true) {
        cin >> _N;
        if (cin.eof() == true)
            break;
        _RootNode.ArrayBinaryNode(_N);
    }

    PostorderTraverse(_RootNode);

	return 0;
}

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

트리의 지름

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

문제

트리(tree)는 사이클이 없는 무방향 그래프이다.

트리에서는 어떤 두 노드를 선택해도 둘 사이에 경로가 항상 하나만 존재하게 된다.

트리에서 어떤 두 노드를 선택해서 양쪽으로 쫙 당길 때, 가장 길게 늘어나는 경우가 있을 것이다.

이럴 때 트리의 모든 노드들은 이 두 노드를 지름의 끝 점으로 하는 원 안에 들어가게 된다.

이런 두 노드 사이의 경로의 길이를 트리의 지름이라고 한다.

정확히 정의하자면 트리에 존재하는 모든 경로들 중에서 가장 긴 것의 길이를 말한다.

입력으로 루트가 있는 트리를 가중치가 있는 간선들로 줄 때, 트리의 지름을 구해서 출력하는 프로그램을 작성하시오.

아래와 같은 트리가 주어진다면 트리의 지름은 45가 된다.

트리의 노드는 1부터 n까지 번호가 매겨져 있다.

입력

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다.

둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다.

간선에 대한 정보는 세 개의 정수로 이루어져 있다.

첫 번째 정수는 간선이 연결하는 두 노드 중 부모 노드의 번호를 나타내고, 두 번째 정수는 자식 노드를, 세 번째 정수는 간선의 가중치를 나타낸다.

간선에 대한 정보는 부모 노드의 번호가 작은 것이 먼저 입력되고, 부모 노드의 번호가 같으면 자식 노드의 번호가 작은 것이 먼저 입력된다.

루트 노드의 번호는 항상 1이라고 가정하며, 간선의 가중치는 100보다 크지 않은 양의 정수이다.

출력

첫째 줄에 트리의 지름을 출력한다.

예제 입력 1

12
1 2 3
1 3 2
2 4 5
3 5 11
3 6 9
4 7 1
4 8 7
5 9 15
5 10 4
6 11 6
6 12 10

예제 출력 1

45

출처

• 문제의 오타를 찾은 사람: apjw6112
• 데이터를 추가한 사람: dlwjsgud12, shg9411, tony9402, yongdol503

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 깊이 우선 탐색

백준 1167번 문제와 비슷한 문제

통과된 코드

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

unsigned short _V, _ResNode;
int _Res;
bool isvisted[100001];

struct Node
{
    unsigned short Number;
    vector<pair<unsigned short, unsigned short>> Connections;
    Node(unsigned short _num) : Number(_num) { };
};

vector<Node> Nodes;

void DFS(unsigned short cntNode, int _dist)
{
    isvisted[cntNode] = true;
    if (Nodes[cntNode].Connections.size() == 1 && _ResNode != cntNode) {
        if (_Res < _dist) {
            _Res = _dist;
            _ResNode = cntNode;
        }
        return;
    }

    for (auto& it : Nodes[cntNode].Connections) {
        if (isvisted[it.first])
            continue;
        DFS(it.first, _dist + it.second);
    }
}


int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> _V;
    for (int i = 0; i <= _V; i++)
        Nodes.push_back(Node(i));

    unsigned short _n1, _n2, _d;
    for (int i = 0; i < _V - 1; i++) {
        cin >> _n1 >> _n2 >> _d;
        Nodes[_n1].Connections.push_back({ _n2, _d });
        Nodes[_n2].Connections.push_back({ _n1, _d });
    }

    _Res = 0;
    _ResNode = 1;
    DFS(1, 0);
    for (int i = 1; i <= _V; i++)
        isvisted[i] = false;
    _Res = 0;
    DFS(_ResNode, 0);
    cout << _Res;
    return 0;
}

The post 백준 1967번 (트리의 지름, 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/1167

문제

트리의 지름이란, 트리에서 임의의 두 점 사이의 거리 중 가장 긴 것을 말한다.

트리의 지름을 구하는 프로그램을 작성하시오.

입력

트리가 입력으로 주어진다.

먼저 첫 번째 줄에서는 트리의 정점의 개수 V가 주어지고 (2 ≤ V ≤ 100,000)

둘째 줄부터 V개의 줄에 걸쳐 간선의 정보가 다음과 같이 주어진다.

정점 번호는 1부터 V까지 매겨져 있다.

먼저 정점 번호가 주어지고, 이어서 연결된 간선의 정보를 의미하는 정수가 두 개씩 주어지는데,

하나는 정점번호, 다른 하나는 그 정점까지의 거리이다.

예를 들어 네 번째 줄의 경우 정점 3은 정점 1과 거리가 2인 간선으로 연결되어 있고,

정점 4와는 거리가 3인 간선으로 연결되어 있는 것을 보여준다. 각 줄의 마지막에는 -1이 입력으로 주어진다.

주어지는 거리는 모두 10,000 이하의 자연수이다.

출력

첫째 줄에 트리의 지름을 출력한다.

예제 입력 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

출처

• 문제의 오타를 찾은 사람: ababc1005, cfghj101, WeissBlume
• 문제를 만든 사람: author5
• 데이터를 추가한 사람: djm03178

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 깊이 우선 탐색

통과된 코드

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

int _V,  _ResNode, _Res;
bool isvisted[100001];

struct Node
{
	int Number;
	vector<pair<int, int>> Connections;
	Node(int _num) : Number(_num) { };
};

vector<Node> Nodes;

void DFS(int cntNode, int _dist) 
{
	isvisted[cntNode] = true;
	if (Nodes[cntNode].Connections.size() == 1 && _ResNode != cntNode) {
		if (_Res < _dist) {
			_Res = _dist;
			_ResNode = cntNode;
		}
		return;
	}

	for (auto& it : Nodes[cntNode].Connections) { 
		if (isvisted[it.first])
			continue;
		DFS(it.first, _dist + it.second);
	}
}


int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _V;
	for (int i = 0; i <= _V; i++) 
		Nodes.push_back(Node(i));
	
	int _n1, _n2, _d;
	for (int i = 1; i <= _V; i++) {
		cin >> _n1;
		while (true) {
			cin >> _n2;
			if (_n2 == -1) break;
			cin >> _d;
			Nodes[_n1].Connections.push_back({ _n2, _d});
		}
	}

	_Res = 0;
	_ResNode = 1;
	DFS(1, 0);
	for (int i = 1; i <= _V; i++)
		isvisted[i] = false;
	_Res = 0;
	DFS(_ResNode, 0);
	cout << _Res;
	return 0;
}

The post 백준 1167번 (트리의 지름, 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 어제와 내일의 나 그 사이의 이야기.