노드사이의 거리

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

문제

 N개의 노드로 이루어진 트리가 주어지고 M개의 두 노드 쌍을 입력받을 때 두 노드 사이의 거리를 출력하라.

입력

첫째 줄에 노드의 개수 N과 거리를 알고 싶은 노드 쌍의 개수 M이 입력되고 다음 N-1개의 줄에 트리 상에 연결된 두 점과 거리를 입력받는다.

그 다음 줄에는 거리를 알고 싶은 M개의 노드 쌍이 한 줄에 한 쌍씩 입력된다.

출력

 M개의 줄에 차례대로 입력받은 두 노드 사이의 거리를 출력한다.

제한

•  2 ≤ N ≤1,000 
•  1 ≤ M ≤ 1,000 
• 트리 상에 연결된 두 점과 거리는 10,000 이하인 자연수이다.
• 트리 노드의 번호는 1부터 N까지 자연수이며, 두 노드가 같은 번호를 갖는 경우는 없다.

4 2
2 1 2
4 3 2
1 4 3
1 2
3 2

2
7

출처

• 빠진 조건을 찾은 사람: hg7258

알고리즘 분류

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

통과된 코드

DFS를 이용하여 탐색

리펙토링하면 메모리와 시간을 더 줄일 수 있음

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAX = 1001;

int N, M, _End;

vector<int> Nodes[MAX];
vector<int> Distances[MAX][MAX];
bool IsVisted[MAX];


void DFS(int _Len, int _CurNode)
{
	if (_End == _CurNode) {
		cout << _Len << '\n';
		return;
	}

	for (int i = 0; i < Nodes[_CurNode].size(); i++)
	{
		int NextNode = Nodes[_CurNode][i];
		if (IsVisted[NextNode]) 
			continue;
		IsVisted[NextNode] = true;
		DFS(_Len + *Distances[_CurNode][NextNode].begin(), NextNode);
		IsVisted[NextNode] = false;
	}

}

int main()
{
	cin >> N >> M;
	int _S, _E, _D;
	for (int i = 0; i < N-1; i++) {
		cin >> _S >> _E >> _D;
		Nodes[_S].push_back(_E);
		Nodes[_E].push_back(_S);
		Distances[_S][_E].push_back(_D);
		Distances[_E][_S].push_back(_D);
	}

	for (int i = 0; i < M; i++) {
		cin >> _S >> _E;
		_End = _E;
		IsVisted[_S] = true;
		DFS(0, _S);
		IsVisted[_S] = false;
	}


	return 0;
}

방문 체크를 빼먹어서 틀렸다.

추가

    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    cin.tie(NULL);
    cout.tie(NULL);

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAX = 1001;

int N, M, _End;

vector<int> Nodes[MAX];
vector<int> Distances[MAX][MAX];
bool IsVisted[MAX];


void DFS(int _Len, int _CurNode)
{
	if (_End == _CurNode) {
		cout << _Len << '\n';
		return;
	}

	for (int i = 0; i < Nodes[_CurNode].size(); i++)
	{
		int NextNode = Nodes[_CurNode][i];
		if (IsVisted[NextNode]) 
			continue;
		IsVisted[NextNode] = true;
		DFS(_Len + *Distances[_CurNode][NextNode].begin(), NextNode);
		IsVisted[NextNode] = false;
	}

}

int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    cin.tie(NULL);
    cout.tie(NULL);
	cin >> N >> M;
	int _S, _E, _D;
	for (int i = 0; i < N-1; i++) {
		cin >> _S >> _E >> _D;
		Nodes[_S].push_back(_E);
		Nodes[_E].push_back(_S);
		Distances[_S][_E].push_back(_D);
		Distances[_E][_S].push_back(_D);
	}

	for (int i = 0; i < M; i++) {
		cin >> _S >> _E;
		_End = _E;
		IsVisted[_S] = true;
		DFS(0, _S);
		IsVisted[_S] = false;
	}


	return 0;
}

The post 백준 1240번 (노드사이의 거리, 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/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/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/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/2251

문제

각각 부피가 A, B, C(1≤A, B, C≤200) 리터인 세 개의 물통이 있다.

처음에는 앞의 두 물통은 비어 있고, 세 번째 물통은 가득(C 리터) 차 있다.

이제 어떤 물통에 들어있는 물을 다른 물통으로 쏟아 부을 수 있는데,

이때에는 한 물통이 비거나, 다른 한 물통이 가득 찰 때까지 물을 부을 수 있다.

이 과정에서 손실되는 물은 없다고 가정한다.

이와 같은 과정을 거치다보면 세 번째 물통(용량이 C인)에 담겨있는 물의 양이 변할 수도 있다.

첫 번째 물통(용량이 A인)이 비어 있을 때,

세 번째 물통(용량이 C인)에 담겨있을 수 있는 물의 양을 모두 구해내는 프로그램을 작성하시오.

입력

첫째 줄에 세 정수 A, B, C가 주어진다.

출력

첫째 줄에 공백으로 구분하여 답을 출력한다. 각 용량은 오름차순으로 정렬한다.

예제 입력 1

8 9 10

예제 출력 1

1 2 8 9 10

출처

Olympiad > USA Computing Olympiad > 2000-2001 Season > USACO Winter 2001 Contest > Orange 4번

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

알고리즘 분류

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

통과된 코드

#include <iostream>
using namespace std;
int _A, _B, _C;
bool _Check[201][201][201];
bool _Numbers[201];

void DFS(int _a, int _b, int _c)
{
	if (_a == 0) {
		_Check[_a][_b][_c] = true;
		_Numbers[_c] = true;
	}
	int  _tA, _tB, _tC;
	if (_a != 0) {
		_tB = _a + _b;
		if (_tB > _B) {
			_tA = _tB - _B;
			_tB = _B;
		}
		else _tA = 0;
		if (!_Check[_tA][_tB][_c]) {
			_Check[_tA][_tB][_c] = true;
			DFS(_tA, _tB, _c);
		}
			
		_tC = _a + _c;
		if (_tC > _C) {
			_tA = _tC - _C;
			_tC = _C;
		}
		else _tA = 0;
		if (!_Check[_tA][_b][_tC]) {
			_Check[_tA][_b][_tC] = true;
			DFS(_tA, _b, _tC);
		}
	}

	if (_b != 0) {
		_tA = _b + _a;
		if (_tA > _A) {
			_tB = _tA - _A;
			_tA = _A;
		}
		else _tB = 0;
		if (!_Check[_tA][_tB][_c]) {
			_Check[_tA][_tB][_c] = true;
			DFS(_tA, _tB, _c);
		}

		_tC = _b + _c;
		if (_tC > _C) {
			_tB = _tC - _C;
			_tC = _C;
		}
		else _tB = 0;
		if (!_Check[_a][_tB][_tC]) {
			_Check[_a][_tB][_tC] = true;
			DFS(_a, _tB, _tC);
		}
	}

	if (_c != 0) {
		_tA = _c + _a;
		if (_tA > _A) {
			_tC = _tA - _A;
			_tA = _A;
		}
		else _tC = 0;
		if (!_Check[_tA][_b][_tC]) {
			_Check[_tA][_b][_tC] = true;
			DFS(_tA, _b, _tC);
		}

		_tB = _c + _b;
		if (_tB > _B) {
			_tC = _tB - _B;
			_tB = _B;
		}
		else _tC = 0;
		if (!_Check[_a][_tB][_tC]) {
			_Check[_a][_tB][_tC] = true;
			DFS(_a, _tB, _tC);
		}
	}


}


int main()
{
	cin >> _A >> _B >> _C;
	_Check[0][0][_C];
	_Numbers[_C];
	DFS(0, 0, _C);
	for (int i = 0; i <= _C; i++)
		if (_Numbers[i])
			cout << i << " ";

	return 0;
}

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

헌내기는 친구가 필요해

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

문제

2020년에 입학한 헌내기 도연이가 있다. 도연이는 비대면 수업 때문에 학교에 가지 못해 학교에 아는 친구가 없었다.

드디어 대면 수업을 하게 된 도연이는 어서 캠퍼스 내의 사람들과 친해지고 싶다. 

도연이가 다니는 대학의 캠퍼스는 N x M 크기이며 캠퍼스에서 이동하는 방법은 벽이 아닌 상하좌우로 이동하는 것이다.

예를 들어, 도연이가 (x, y)에 있다면 이동할 수 있는 곳은 (x+1, y), (x, y+1), (x-1, y), (x, y-1)이다.

단, 캠퍼스의 밖으로 이동할 수는 없다.

불쌍한 도연이를 위하여 캠퍼스에서 도연이가 만날 수 있는 사람의 수를 출력하는 프로그램을 작성해보자.

입력

첫째 줄에는 캠퍼스의 크기를 나타내는 두 정수 N (1 ≤ N ≤ 600), M (1 ≤ M ≤ 600)이 주어진다.

둘째 줄부터 N개의 줄에는 캠퍼스의 정보들이 주어진다. 

O는 빈 공간, X는 벽, I는 도연이, P는 사람이다. 

I가 한 번만 주어짐이 보장된다.

출력

첫째 줄에 도연이가 만날 수 있는 사람의 수를 출력한다.

단, 아무도 만나지 못한 경우 TT를 출력한다.

예제 입력 1

3 5
OOOPO
OIOOX
OOOXP

예제 출력 1

1

예제 입력 2

3 3
IOX
OXP
XPP

예제 출력 2

TT

출처

University > 숙명여자대학교 > 제1회 숙명여자대학교 교내 알고리즘 경진대회 (SMUPC) C번

• 문제를 검수한 사람: cs71107, lky7674, plast, sait2000, songfox00, wbcho0504, whaeun25
• 문제를 만든 사람: swoon

알고리즘 분류

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

통과된 코드

DFS 탐색을 재귀로 구현하여 문제를 해결

#include <iostream>
using namespace std;
int _Res = 0, _N, _M;
int _DxDy[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
char _Map[600][600];
string _Str;
char _Temp;
pair<int, int> StartPos;

// 재귀를 이용한 DFS (Depth-First Search) 탐색 
void DFSSearch(int _CntX, int _CntY)
{
	for (int j = 0; j < 4; j++) {
		int _dx = _CntX + _DxDy[j][0];
		int _dy = _CntY + _DxDy[j][1];
		if (_dx >= _N || _dy >= _M || _dx < 0 || _dy < 0)
			continue;
		if (_Map[_dx][_dy] == 'X')
			continue;
		if (_Map[_dx][_dy] == 'P')
			_Res++;
		// 방문처리 대신에 X(벽)으로 마킹
		_Map[_dx][_dy] = 'X';
		DFSSearch(_dx, _dy);
	}
}

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] == 'I') {
				StartPos = make_pair(i, j);
				_Map[i][j] = 'X';
			}
		}
	}
	
	DFSSearch(StartPos.first, StartPos.second);

	if (_Res == 0) cout << "TT"; 
	else  cout << _Res;

	return 0;
}

The post 백준 21736번 (헌내기는 친구가 필요해, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

숨바꼭질 2

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

문제

수빈이는 동생과 숨바꼭질을 하고 있다.

수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다.

수빈이는 걷거나 순간이동을 할 수 있다.

만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다.

순간이동을 하는 경우에는 1초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때,

수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지

그리고, 가장 빠른 시간으로 찾는 방법이 몇 가지 인지 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. 

N과 K는 정수이다.

출력

첫째 줄에 수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.

둘째 줄에는 가장 빠른 시간으로 수빈이가 동생을 찾는 방법의 수를 출력한다.

예제 입력 1

5 17

예제 출력 1

4
2

출처

• 문제를 만든 사람: baekjoon

통과된 코드

일반적으로 BFS 방문 체크는 Queue에 넣기 전에 해주지만

이 문제는 Queue에서 꺼내는 경우 방문 처리를 해주면 된다.

#include <iostream>
#include <queue>
using namespace std;
queue<pair<int, int>> _BfsQueue;
bool _isVisted[100001];
int _N, _K, _Res = INT32_MAX ,_ResCnt;
int main()
{
	cin >> _N >> _K;
	// 위치, 시간
	pair<int, int> _Pos = make_pair(_N, 0);
	_BfsQueue.push(_Pos);
	while (!_BfsQueue.empty()) {
		_Pos = _BfsQueue.front();
		_BfsQueue.pop();
		int _pos = _Pos.first;
		if (_Res < _Pos.second)
			break;
		_isVisted[_pos] = true;

		if (_pos == _K) {
			_isVisted[_pos] = false;
			_Res = _Pos.second;
			_ResCnt++;
		}

		for (int i = 0; i < 3; i++) {
			switch (i)
			{
				case 0:
					_pos = _Pos.first - 1;
					break;
				case 1:
					_pos = _Pos.first + 1;
					break;
				case 2:
					_pos = _Pos.first * 2;
					break;
			}

			if (_pos <= -1 || _pos >= 100001 || (_isVisted[_pos]))
				continue;
			_BfsQueue.push(make_pair(_pos, _Pos.second + 1));		
		}
	}

	cout << _Res << "\n" << _ResCnt;

	return 0;
}

The post 백준 12851번 (숨바꼭질 2, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

불

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

문제

상근이는 빈 공간과 벽으로 이루어진 건물에 갇혀있다.

건물의 일부에는 불이 났고, 상근이는 출구를 향해 뛰고 있다.

매 초마다, 불은 동서남북 방향으로 인접한 빈 공간으로 퍼져나간다.

벽에는 불이 붙지 않는다. 상근이는 동서남북 인접한 칸으로 이동할 수 있으며, 1초가 걸린다.

상근이는 벽을 통과할 수 없고, 불이 옮겨진 칸 또는 이제 불이 붙으려는 칸으로 이동할 수 없다.

상근이가 있는 칸에 불이 옮겨옴과 동시에 다른 칸으로 이동할 수 있다.

빌딩의 지도가 주어졌을 때, 얼마나 빨리 빌딩을 탈출할 수 있는지 구하는 프로그램을 작성하시오.

입력

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

테스트 케이스는 최대 100개이다.

각 테스트 케이스의 첫째 줄에는 빌딩 지도의 너비와 높이 w와 h가 주어진다. (1 ≤ w,h ≤ 1000)

다음 h개 줄에는 w개의 문자, 빌딩의 지도가 주어진다.

• ‘.’: 빈 공간
• ‘#’: 벽
• ‘@’: 상근이의 시작 위치
• ‘*’: 불

각 지도에 @의 개수는 하나이다.

출력

각 테스트 케이스마다 빌딩을 탈출하는데 가장 빠른 시간을 출력한다.

빌딩을 탈출할 수 없는 경우에는 “IMPOSSIBLE”을 출력한다.

예제 입력 1

5
4 3
####
#*@.
####
7 6
###.###
#*#.#*#
#.....#
#.....#
#..@..#
#######
7 4
###.###
#....*#
#@....#
.######
5 5
.....
.***.
.*@*.
.***.
.....
3 3
###
#@#
###

예제 출력 1

2
5
IMPOSSIBLE
IMPOSSIBLE
IMPOSSIBLE

출처

ICPC > Regionals > Europe > Northwestern European Regional Contest > Benelux Algorithm Programming Contest > BAPC 2012 F번

• 문제의 오타를 찾은 사람: adh0463
• 데이터를 추가한 사람: b8goal, djm03178
• 문제를 번역한 사람: baekjoon

알고리즘 분류

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

통과된 코드

해당 좌표에 불이 언제 도착하는지 먼저 BFS 탐색을 이용하여 확인하고

상근이의 위치에서 BFS 탐색을 이용하여 출구를 찾는다.

#include <iostream>
#include <queue>

using namespace std;

int _T, _W, _H, _Res;
pair<int, int> _CntPos;
int _Map[1002][1002];
bool _IsVisted[1002][1002], _Check;
string _TStr;
// 상, 하, 좌, 우
int _DxDy[4][2] = { {1,0}, {-1,0}, {0,1}, {0,-1} };
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _T;
	while (_T-- > 0) {
		cin >> _W >> _H;
		queue<pair<int, int>> _FireQueue;
		_Check = false;
		for (int i = 1; i <= _H; i++) {
			cin >> _TStr;
			for (int j = 1; j <= _W; j++) {
				if (_TStr[j - 1] == '@') _CntPos = make_pair(i, j);
				else if (_TStr[j - 1] == '*') {
					_Map[i][j] = 1;
					_FireQueue.push(make_pair(i, j));
				}
				else if (_TStr[j - 1] == '#')
					_Map[i][j] = -1;
			}
		}

		while (!_FireQueue.empty()) {
			pair<int, int> _CntFirePos = _FireQueue.front();
			_FireQueue.pop();
			for (int i = 0; i < 4; i++) {
				int _dx = _CntFirePos.first + _DxDy[i][0];
				int _dy = _CntFirePos.second + _DxDy[i][1];
				// 이미 불이 있거나 벽이면 넘어간다.
				if (_Map[_dx][_dy] == -1) continue;
				if (_Map[_dx][_dy] > 0) continue;
				// 범위를 벗어나는 경우 넘어간다.
				if (_dx > _H || _dx <= 0 || _dy > _W || _dy <= 0) continue;
				_Map[_dx][_dy] = _Map[_CntFirePos.first][_CntFirePos.second] + 1;
				_FireQueue.push(make_pair(_dx, _dy));
			}
		}

		// 순서, x, y
		queue< pair<int, pair<int, int>>> _BFSQueue;
		_BFSQueue.push(make_pair(1, _CntPos));
		_IsVisted[_CntPos.first][_CntPos.second] = true;
		while (!_BFSQueue.empty()) {
			int _cnt = _BFSQueue.front().first;
			pair<int, int> _cntPos = _BFSQueue.front().second;
			_BFSQueue.pop();
			for (int i = 0; i < 4; i++) {
				int _dx = _cntPos.first + _DxDy[i][0];
				int _dy = _cntPos.second + _DxDy[i][1];
				// 벽이거나 해당 칸에 불이 붙는 순서와 비교하여 갈 수 없으면 넘어간다.
				if (_Map[_dx][_dy] == -1 || (_Map[_dx][_dy] <= _cnt + 1 && _Map[_dx][_dy] != 0) || _IsVisted[_dx][_dy]) continue;
				// 탈출에 성공하는 경우
				if (_dx > _H || _dx <= 0 || _dy > _W || _dy <= 0) {
					_Res = _cnt;
					_Check = true;
					break;
				}

				_BFSQueue.push(make_pair(_cnt + 1, make_pair(_dx, _dy)));
				_IsVisted[_dx][_dy] = true;
			}
			if (_Check)
				break;
		}

		if (_Check) cout << _Res << "\n";
		else cout << "IMPOSSIBLE" << "\n";

		// 초기화
		for (int i = 1; i <= _H; i++) {
			for (int j = 1; j <= _W; j++) {
				_Map[i][j] = 0;
				_IsVisted[i][j] = false;
			}
		}
	}

	return 0;
}

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

보물 지도

https://school.programmers.co.kr/learn/courses/15009/lessons/121690

문제 설명

진수는 보물이 묻힌 장소와 함정이 표시된 보물 지도를 이용해 보물을 찾으려 합니다.

보물지도는 가로 길이가 n, 세로 길이가 m인 직사각형 모양입니다.

맨 왼쪽 아래 칸의 좌표를 (1, 1)으로, 맨 오른쪽 위 칸의 좌표를 (n, m)으로 나타냈을 때, 보물은 (n, m) 좌표에 묻혀있습니다.

또한, 일부 칸에는 함정이 있으며, 해당 칸으로는 지나갈 수 없습니다.

진수는 처음에 (1, 1) 좌표에서 출발해 보물이 있는 칸으로 이동하려 합니다.

이동할 때는 [상,하,좌,우]로 인접한 네 칸 중 한 칸으로 걸어서 이동합니다.

한 칸을 걸어서 이동하는 데 걸리는 시간은 1입니다.

진수는 보물이 위치한 칸으로 수월하게 이동하기 위해 신비로운 신발을 하나 준비했습니다.

이 신발을 신고 뛰면 한 번에 두 칸을 이동할 수 있으며, 함정이 있는 칸도 넘을 수 있습니다.

하지만, 이 신발은 한 번밖에 사용할 수 없습니다.

신비로운 신발을 사용하여 뛰어서 두 칸을 이동하는 시간도 1입니다.

이때 진수가 출발점에서 보물이 위치한 칸으로 이동하는데 필요한 최소 시간을 구해야 합니다.

예를 들어, 진수의 보물지도가 아래 그림과 같을 때, 진수가 걸어서 오른쪽으로 3칸,

걸어서 위쪽으로 3칸 이동하면 6의 시간에 보물이 위치한 칸으로 이동할 수 있습니다.

만약, 오른쪽으로 걸어서 1칸, 위쪽으로 걸어서 1칸, 신비로운 신발을 사용하여 위로 뛰어 2칸,

오른쪽으로 걸어서 2칸 이동한다면 총 5의 시간에 보물이 위치한 칸으로 이동할 수 있으며,

이보다 빠른 시간 내에 보물이 있는 위치에 도착할 수 없습니다.

진수의 보물지도가 표현하는 지역의 가로 길이를 나타내는 정수 n,

세로 길이를 나타내는 정수 m, 함정의 위치를 나타내는 2차원 정수 배열 hole이 주어졌을 때,

진수가 보물이 있는 칸으로 이동하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 

단, 보물이 있는 칸으로 이동할 수 없다면, -1을 return 해야 합니다.

제한사항

• 1 ≤ n, m ≤ 1,000
  • 단, n * m이 3 이상인 경우만 입력으로 주어집니다.
• 1 ≤ hole의 길이 ≤ n * m – 2
  • hole[i]는 [a, b]의 형태이며, (a, b) 칸에 함정이 존재한다는 의미이며, 1 ≤ a ≤ n, 1 ≤ b ≤ m을 만족합니다.
  • 같은 함정에 대한 정보가 중복해서 들어있지 않습니다.
• (1, 1) 칸과 (n, m) 칸은 항상 함정이 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 본문의 예시와 같습니다.

입출력 예 #2

• 보물지도를 그림으로 나타내면 아래와 같으며, 보물이 위치한 칸으로 이동할 수 없습니다.
  따라서, -1을 return 해야 합니다.

통과된 코드

신발은 구멍과 상관없이 사용해도 된다.

#include <string>
#include <vector>
#include <tuple>
#include <queue>
bool _Map[1001][1001];
bool _IsVisted[1001][1001][2]; // 배열의 마지막은 신발의 사용 유무
int _dxdy[8][2] = { {1,0},{0,1},{-1,0},{0,-1}, {2,0},{0,2},{-2,0},{0,-2} };
using namespace std;
int solution(int n, int m, vector<vector<int>> holeVector) {
    int answer = -1;
	for (auto& hole : holeVector)
		_Map[hole[0]][hole[1]] = true;
	tuple<int, int, bool, int> _CntPos = make_tuple(1, 1, true, 0);
	queue<tuple<int, int, bool, int>> _MyQueue;
	_IsVisted[1][1][1] = true;
	_MyQueue.push(_CntPos);
	while (!_MyQueue.empty()) {
		_CntPos = _MyQueue.front();
		_MyQueue.pop();
		int _cntX = get<0>(_CntPos);
		int _cntY = get<1>(_CntPos);
		bool _shoes = get<2>(_CntPos);
		int _cnt = get<3>(_CntPos);	

		// 목적지에 도착
		if (_cntX == n && _cntY == m) {
				answer = _cnt;
				break;
		}

		// 총 8가지의 경우를 탐색
		// 0 ~ 3 상,하,좌,우
		// 4 ~ 7 신발을 사용하여 상,하,좌,우를 2칸씩 이동
		// 꼭 구멍이 있어야 신발을 사용하는 것이 아니다.
		for (int i = 0; i < 8; i++) {
			if (!_shoes && i >= 4) break;
			int _dx = _cntX + _dxdy[i][0];
			int _dy = _cntY + _dxdy[i][1];
			// 맵의 범위를 벗어나는 경우
			if (_dx > n || _dy > m || _dx <= 0 || _dy <= 0 ) 
				continue;
			// 이동을 하려던 곳이 구멍 && 신발이 없음 || 이미 방문한 적이 있다.
			if (_Map[_dx][_dy] || _IsVisted[_dx][_dy][_shoes])
				continue;

			if (i >= 4) { // 신발을 사용하여 이동하는 경우
				_MyQueue.push(make_tuple(_dx, _dy, false, _cnt + 1));
				_IsVisted[_dx][_dy][false] = true;
			}
			else { // 신발을 사용하지 않는 경우
				_MyQueue.push(make_tuple(_dx, _dy, _shoes, _cnt + 1));
				_IsVisted[_dx][_dy][_shoes] = true;
			}

		}
	}

	return answer;
}

The post Programmers 121690 4번 보물 지도 [PCCP 모의고사 2회] appeared first on 어제와 내일의 나 그 사이의 이야기.