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

문제

강호네 회사에는 직원이 N명이 있고, 해야할 일이 M개가 있다.

직원은 1번부터 N번까지 번호가 매겨져 있고, 일은 1번부터 M번까지 번호가 매겨져 있다.

각 직원은 자신이 할 수 있는 일들 중 한 개의 일만 담당할 수 있고, 각각의 일을 담당하는 사람은 1명이어야 한다.

각각의 직원이 할 수 있는 일의 목록이 주어졌을 때, M개의 일 중에서 최대 몇 개를 할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 직원의 수 N과 일의 개수 M이 주어진다. (1 ≤ N, M ≤ 1,000)

둘째 줄부터 N개의 줄의 i번째 줄에는 i번 직원이 할 수 있는 일의 개수와 할 수 있는 일의 번호가 주어진다.

출력

첫째 줄에 강호네 회사에서 할 수 있는 일의 개수를 출력한다.

예제 입력 1

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

예제 출력 1

4

출처

• 문제를 만든 사람: baekjoon
• 어색한 표현을 찾은 사람: doju
• 데이터를 추가한 사람: rubix, woojw911

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> employee[1001];
int works[1001];       
bool visited[1001];      

bool DFS(int n) 
{

    for (int work : employee[n]) 
    {
        if (visited[work]) 
            continue;

        visited[work] = true;

        if (works[work] == 0 || DFS(works[work])) 
        {
            works[work] = n;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, work;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> work;
            employee[i].push_back(work);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

해당 문제와 코드가 같은 문제

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

The post 백준 11375번 (열혈강호, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

농부 존은 소 축사를 완성하였다. 축사 환경을 쾌적하게 유지하기 위해서, 존은 축사를 M개의 칸으로 구분하고, 한 칸에는 최대 한 마리의 소만 들어가게 계획했다.

첫 주에는 소를 임의 배정해서 축사를 운영했으나, 곧 문제가 발생하게 되었다. 바로 소가 자신이 희망하는 몇 개의 축사 외에는 들어가기를 거부하는 것이다.

농부 존을 도와 최대한 많은 수의 소가 축사에 들어갈 수 있도록 하는 프로그램을 작성하시오.

축사의 번호는 1부터 M까지 매겨져 있다.

입력

첫째 줄에 소의 수 N과 축사의 수 M이 주어진다. (1 ≤ N, M ≤ 200)

둘째 줄부터 N개의 줄에는 각 소가 들어가기 원하는 축사에 대한 정보가 주어진다.

i번째 소가 들어가기 원하는 축사의 수 S_i (0 ≤ S_i ≤ M)이 먼저 주어지고, 이후 S_i개의 축사 번호가 주어진다.

같은 축사 번호가 두 번 이상 주어지는 경우는 없다.

출력

첫째 줄에 축사에 들어갈 수 있는 소의 최댓값을 출력한다.

예제 입력 1

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

예제 출력 1

4

https://www.acmicpc.net/board/view/137221

예제 입력 A

4 3
1 1
1 2
1 3
1 3

예제 출력 A

3

예제 입력 B

4 3
0
0
0
0

예제 출력 B

0

예제 입력 C

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

예제 출력 C

2

예제 입력 D

50 40
2 24 21
1 39
4 30 31 15 18
2 21 3
4 21 40 39 30
1 20
5 20 30 4 29 25
3 39 9 33
1 32
5 27 22 36 2 11
1 9
5 35 29 14 38 1
3 28 22 1
4 18 20 29 22
3 5 11 38
2 36 30
5 9 17 35 10 19
3 18 31 7
3 4 36 30
4 24 12 9 14
3 28 2 27
3 13 6 2
3 6 37 39
4 5 26 15 16
3 25 6 36
2 9 31
3 17 6 7
5 27 4 13 29 30
1 1
1 12
5 3 1 38 8 5
2 14 12
3 17 39 12
3 30 15 26
2 21 3
3 7 6 11
2 28 13
2 25 16
2 19 16
1 13
5 39 24 34 29 33
2 40 10
3 6 35 40
1 37
2 24 35
4 11 22 3 29
3 19 7 16
1 14
1 38
5 31 14 28 19 6

예제 출력 D

39

출처

• 데이터를 추가한 사람: djm03178, rubix
• 문제의 오타를 찾은 사람: hun3555

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> cowInfo[201]; // 각 소가 원하는 축사 리스트
int barnMatch[201];       // barnMatch[b] = 소 번호 (b번 축사에 배정된 소)
bool visited[201];        // DFS 방문 체크

// 축사 매칭 시도
bool DFS(int cow) 
{

    for (int barn : cowInfo[cow]) 
    {
        if (visited[barn]) 
            continue;

        visited[barn] = true;

        // 이 축사가 비었거나, 이미 배정된 소가 다른 축사로 갈 수 있다면
        if (barnMatch[barn] == 0 || DFS(barnMatch[barn])) 
        {
            barnMatch[barn] = cow;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, barn;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> barn;
            cowInfo[i].push_back(barn);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

백준에 해당 문제와 코드가 같은 문제

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

The post 백준 2188번 (축사 배정, C++) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

노드사이의 거리

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/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 어제와 내일의 나 그 사이의 이야기.

맥주 마시면서 걸어가기

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

문제

송도에 사는 상근이와 친구들은 송도에서 열리는 펜타포트 락 페스티벌에 가려고 한다.

올해는 맥주를 마시면서 걸어가기로 했다. 출발은 상근이네 집에서 하고, 맥주 한 박스를 들고 출발한다.

맥주 한 박스에는 맥주가 20개 들어있다. 목이 마르면 안되기 때문에 50미터에 한 병씩 마시려고 한다. 

즉, 50미터를 가려면 그 직전에 맥주 한 병을 마셔야 한다.

상근이의 집에서 페스티벌이 열리는 곳은 매우 먼 거리이다.

따라서, 맥주를 더 구매해야 할 수도 있다.

미리 인터넷으로 조사를 해보니 다행히도 맥주를 파는 편의점이 있다.

편의점에 들렸을 때, 빈 병은 버리고 새 맥주 병을 살 수 있다.

하지만, 박스에 들어있는 맥주는 20병을 넘을 수 없다. 

편의점을 나선 직후에도 50미터를 가기 전에 맥주 한 병을 마셔야 한다.

편의점, 상근이네 집, 펜타포트 락 페스티벌의 좌표가 주어진다.

상근이와 친구들이 행복하게 페스티벌에 도착할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 t가 주어진다. (t ≤ 50)

각 테스트 케이스의 첫째 줄에는 맥주를 파는 편의점의 개수 n이 주어진다. (0 ≤ n ≤ 100).

다음 n+2개 줄에는 상근이네 집, 편의점, 펜타포트 락 페스티벌 좌표가 주어진다.

각 좌표는 두 정수 x와 y로 이루어져 있다. (두 값 모두 미터, -32768 ≤ x, y ≤ 32767)

송도는 직사각형 모양으로 생긴 도시이다.

두 좌표 사이의 거리는 x 좌표의 차이 + y 좌표의 차이 이다. (맨해튼 거리)

출력

각 테스트 케이스에 대해서 상근이와 친구들이 행복하게 페스티벌에 갈 수 있으면 “

happy”, 중간에 맥주가 바닥나서 더 이동할 수 없으면 “sad”를 출력한다. 

예제 입력 1

2
2
0 0
1000 0
1000 1000
2000 1000
2
0 0
1000 0
2000 1000
2000 2000

예제 출력 1

happy
sad

출처

ICPC > Regionals > Europe > Northwestern European Regional Contest > German Collegiate Programming Contest > GCPC 2013 D번

• 문제를 번역한 사람: baekjoon
• 문제의 잘못된 점을 전체적으로 찾은 사람: jh05013
• 어색한 표현을 찾은 사람: ljh6274
• 문제의 오타를 찾은 사람: mwy3055
• 데이터를 추가한 사람: rhdqor213

알고리즘 분류

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

통과된 코드

50미터마다 맥주를 1병씩 소모, 최대 수량은 20병, 따라서 최대로 움직일 수 있는 거리는 1000미터다.

입력 받은 편의점의 위치에서 1000미터 내로 도달할 수 있는 편의점을 탐색 후

해당 위치에서 다시 편의점을 찾는 방법으로 해결하였다. (재귀로 구현)

다른 분들의 풀이를 보면 BFS 탐색으로 풀 수 있는 듯 하다.

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

constexpr int MAX = 101;

int T, N;

vector<pair<int, int>> graph[MAX];

bool isVisted[MAX], check;

pair<int, int> Start, Temp;

void DFSSearch(int x, int y)
{
	// 도착이 가능하다면 마킹하고 리턴
	if (x == graph[N][0].first && y == graph[N][0].second) {
		check = true;
	}

	for (int i = 0; i <= N; i++) {

		// 방문 했다면 넘어간다. 
		if (isVisted[i] == true) continue;
		// 거리의 절대값으로 도착이 가능한지 불가능한지 체크
		if (abs(graph[i][0].first - x) + abs(graph[i][0].second - y) <= 1000) {

			isVisted[i] = true; // 방문 체크

			DFSSearch(graph[i][0].first, graph[i][0].second);
			// isVisted[i] = false; // 방문 체크를 해제하면 시간초과
		}
	}
}


int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> T;

	while (T--) {

		// 조건 초기화
		fill(isVisted, isVisted + MAX, false);

		for (int i = 0; i < MAX; i++) graph[i].clear();

		check = false; // 가능한지 불가능한지 탐색

		// 시작 위치를 입력
		cin >> N >> Start.first >> Start.second;	

		for (int i = 0; i <= N; i++) {

			// 편의점의 위치를 입력받는다.
			cin >> Temp.first >> Temp.second;
			// 마지막은 도착 위치를 입력받는다.
			graph[i].push_back(make_pair(Temp.first, Temp.second));

		}

		DFSSearch(Start.first, Start.second);
		
		if (check) cout << "happy\n";
		else cout << "sad\n";

	}

	return 0;
}

재귀 탐색에서 사용하는 방문 체크 해제에 대한 문제로 시간 초과가 발생하였다.

DFS를 나갈 때 visited를 다시 false 변경할 필요가 있는지 생각

The post 백준 9205번 (맥주 마시면서 걸어가기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

연결 요소의 개수

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

문제

방향 없는 그래프가 주어졌을 때, 연결 요소 (Connected Component)의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 정점의 개수 N과 간선의 개수 M이 주어진다. (1 ≤ N ≤ 1,000, 0 ≤ M ≤ N×(N-1)/2)

둘째 줄부터 M개의 줄에 간선의 양 끝점 u와 v가 주어진다. (1 ≤ u, v ≤ N, u ≠ v)

같은 간선은 한 번만 주어진다.

출력

첫째 줄에 연결 요소의 개수를 출력한다.

예제 입력 1

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

예제 출력 1

2

예제 입력 2

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

예제 출력 2

1

예제 입력 A

3 2
1 2
3 2

예제 출력 A

1

예제 입력 B

10 3
3 4
4 6
9 6

예제 출력 B

7

예제 입력 C

1000 0

예제 출력 C

1000

예제 입력 D

1 0

예제 출력 D

1

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: djm03178, seoo2001, YunGoon
• 잘못된 조건을 찾은 사람: songjuh

알고리즘 분류

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

자료구조는 2차원 배열을 사용하였다.

arr[N][0] 은 방문 처리 용도

arr[A][B] 가 true면 A – B (연결)을 나타낸다.

이 문제는 시간 제한과 메모리 제한을 보면 BFS / DFS 등 어느 것을 사용해도 상관없는 문제

통과된 코드

#include <iostream>

using namespace std;

int N, M, cnt = 0;

pair<int, int> tempPair;

bool arr[1001][1001];

void CheckNode(int A) // DFS
{
	arr[A][0] = false; // 방문처리
	for (int i = 1; i <= N; i++) {
		if (A == i) continue;

		// 양방향 탐색
		if ((arr[i][0] == true && arr[i][A] == true) || (arr[i][0] == true && arr[A][i] == true)) 
			CheckNode(i);
	}
}


int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> M;

	// 자기 자신은 항상 자기 자신의 연결 요소에 속한다.
	for (int i = 1; i <= N; i++) arr[i][0] = true;


	for (int i = 0; i < M; i++) {
		cin >> tempPair.first >> tempPair.second;
		arr[tempPair.first][tempPair.second] = true;
		arr[tempPair.first][0] = true;
		arr[tempPair.second][0] = true;
	}

	for (int i = 1; i <= N; i++) {
		if (arr[i][0] == false) continue; // 방문처리가 되어있다면 넘어간다.
		else 
		{
			CheckNode(i);
			cnt++; // 연결요소 카운트 + 1
		}
	}

	cout << cnt;

	return 0;
}

자기 자신만 있는 경우를 연결 요소로 카운트하지 않아서 방황했다.

The post 백준 11724번 (연결 요소의 개수, C++, DFS) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.