여러분의 다리가 되어 드리겠습니다!

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

문제

선린월드에는 N개의 섬이 있다. 섬에는 1, 2, …, N의 번호가 하나씩 붙어 있다. 

그 섬들을 N – 1개의 다리가 잇고 있으며, 어떤 두 섬 사이든 다리로 왕복할 수 있다.

어제까지는 그랬다.

“왜 다리가 N – 1개밖에 없냐, 통행하기 불편하다”며 선린월드에 불만을 갖던 욱제가 다리 하나를 무너뜨렸다!

안 그래도 불편한 통행이 더 불편해졌다. 서로 왕복할 수 없는 섬들이 생겼기 때문이다.

일단 급한 대로 정부는 선린월드의 건축가를 고용해,

서로 다른 두 섬을 다리로 이어서 다시 어떤 두 섬 사이든 왕복할 수 있게 하라는 지시를 내렸다.

그런데 그 건축가가 당신이다! 안 그래도 천하제일 코딩대회에 참가하느라 바쁜데…

입력

첫 줄에 정수 N이 주어진다. (2 ≤ N ≤ 300,000)

그 다음 N – 2개의 줄에는 욱제가 무너뜨리지 않은 다리들이 잇는 두 섬의 번호가 주어진다.

출력

다리로 이을 두 섬의 번호를 출력한다.

여러 가지 방법이 있을 경우 그 중 아무거나 한 방법만 출력한다.

예제 입력 1

4
1 2
1 3

예제 출력 1

1 4

“4 1″이나 “2 4”, “4 3” 등 가능한 정답은 많이 있지만, 아무거나 하나만 출력해야 한다.

예제 입력 2

2

예제 출력 2

1 2

예제 입력 3

5
1 2
2 3
4 5

예제 출력 3

3 4

출처

High School > 선린인터넷고등학교 > 제3회 천하제일 코딩대회 D번

• 문제를 만든 사람: jh05013

알고리즘 분류

• 자료 구조
• 그래프 이론
• 그래프 탐색
• 분리 집합

접근 방법

통과된 코드

#include <iostream>

using namespace std;

constexpr int MAX = 300001;

int N, v, u;

int parent[MAX];

void MakeSet(int n)
{
	for (int i = 1; i <= n; i++)  parent[i] = i;
}

int Find(int x) {

	if (parent[x] != x) parent[x] = Find(parent[x]); // Path compression

	return parent[x];
}

void Unite(int x, int y) {
	int rootX = Find(x);
	int rootY = Find(y);
	parent[rootY] = rootX; // Make rootX the parent of rootY
}

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

	cin >> N;
	MakeSet(N);
	for (int i = 0; i < N - 2; i++) {
		cin >> v >> u;
		Unite(v, u);
	}

	int first, second = -1;
	first = Find(1);
	for (int i = 2; i <= N; i++) {
		if (Find(i) != first) {
			second = Find(i);
			break;
		}
	}

	cout << first << " " << second;

	return 0;
}

The post 백준 17352번 (여러분의 다리가 되어 드리겠습니다!, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

유니온 파인드(Union find) & 서로소 집합(Disjoint Set)?

Union find는 대표적인 그래프 알고리즘으로

집합 내의 요소의 연결성을 효율적으로 추적하는 데 사용되는 데이터 구조 및 알고리즘입니다.

역으로 서로 연결되어 있지 않은 노드를 판별할 수도 있기 때문에 서로소 집합 (Disjoint-set)이라고도 합니다.

알고리즘은 union과 find의 두 가지 연산으로 구성되어 있습니다.

-> union 은 각 노드가 속한 집합을 1개로 합치는 연산

-> find 특정 노드 A에 관해 A가 속한 대표 노드를 반환하는 연산

Union-Find 알고리즘은 집합 내 요소의 연결성을 추적하는 데 유용한 데이터 구조 및 알고리즘입니다.

이것은 많은 그래프 알고리즘에서 사용될 수 있으며 경로 압축 최적화로 O(log n) ~ O(n)의 시간 복잡도를 가집니다.

예제 코드 C++

#include <iostream>
#include <vector>

using namespace std;

// Initialize the parent array
void makeSet(int parent[], int n) {
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }
}

// Find the root of the set containing node x
int find(int parent[], int x) {
    if (parent[x] != x) {
        parent[x] = find(parent, parent[x]); // Path compression
    }
    return parent[x];
}

// Merge the sets containing nodes x and y
void unite(int parent[], int x, int y) {
    int rootX = find(parent, x);
    int rootY = find(parent, y);
    parent[rootY] = rootX; // Make rootX the parent of rootY
}

int n = 5; // Number of nodes
int parent[5]; // Number of nodes

int main() {


    makeSet(parent, n); // Initialize the parent array

    // Merge sets containing nodes 2 and 4
    unite(parent, 2, 4);

    // Merge sets containing nodes 1 and 5
    unite(parent, 1, 5);

    // Merge sets containing nodes 1 and 2
    unite(parent, 1, 2);

    // Find the set of node 4
    int root4 = find(parent, 4);

    // Print the parent array
    for (int i = 0; i < n; i++) {
        cout << parent[i] << " ";
    }
    cout << endl;

    // Print the root of the set containing node 4
    cout << "The root of the set containing node 4 is " << root4 << endl;

    return 0;
}

백준 예제

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

#include <iostream>

using namespace std;

constexpr int Max = 1000001;

// 유니온 root노드 배열
int uArr[Max];

int N, M, u, b, c;

//부모를 찾는 함수
//모든 경로가 부모를 가르키게 함
//상수 시간의 복잡도
int Find(int x)
{
    if (uArr[x] == x) return x;
    return uArr[x] = Find(uArr[x]);
}

//두 노드를 연결 시키는 것
//기준을 정해서 연결시키는 것이 헷갈리지 않음
//작은쪽이 부모 or 큰쪽이 부모
void Union(int x, int y)
{
    x = Find(x);
    y = Find(y);

    if (x != y) {
        if (x < y) uArr[y] = x;
        else uArr[x] = y;
    }
}

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 = 0; i <= N; i++) uArr[i] = i;

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

        cin >> u >> b >> c;

        if (u == 0) { // 합집합 연산
            Union(b, c);
        }
        else { // 질의
            if (Find(b) != Find(c)) cout << "NO\n";
            else cout << "YES\n";
        }
    }

    return 0;
}

백준 Union find Algorithm 문제

https://www.acmicpc.net/problemset?sort=ac_desc&algo=81

알고리즘 – 유니온 파인드(Union find) & 서로소 집합(Disjoint Set)

더 읽기

백준 17352번 (여러분의 다리가 되어 드리겠습니다!, C++) [BAEKJOON]

더 읽기

백준 1717번 (집합의 표현, C++, Union-Find) [BAEKJOON]

더 읽기

백준 2610번 (회의준비, C++) [BAEKJOON]

더 읽기

The post 알고리즘 – 유니온 파인드(Union find) & 서로소 집합(Disjoint Set) appeared first on 어제와 내일의 나 그 사이의 이야기.

회의준비

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

문제

KOI 준비를 위해 회의를 개최하려 한다.

주최측에서는 회의에 참석하는 사람의 수와 참석자들 사이의 관계를 따져 하나 이상의 위원회를 구성하려고 한다.

위원회를 구성하는 방식은 다음과 같다.

1. 서로 알고 있는 사람은 반드시 같은 위원회에 속해야 한다.

2. 효율적인 회의 진행을 위해 위원회의 수는 최대가 되어야 한다.

이런 방식으로 위원회를 구성한 후에 각 위원회의 대표를 한 명씩 뽑아야 한다.

각 위원회의 대표만이 회의 시간 중 발언권을 가지며,

따라서 회의 참석자들이 자신의 의견을 말하기 위해서는 자신이 속한 위원회의 대표에게 자신의 의견을 전달해야 한다.

그런데 각 참석자는 자신이 알고 있는 사람에게만 의견을 전달할 수 있어 대표에게 의견을 전달하기 위해서는 때로 여러 사람을 거쳐야 한다.

대표에게 의견을 전달하는 경로가 여러 개 있을 경우에는 가장 적은 사람을 거치는 경로로 의견을 전달하며

이때 거치는 사람의 수를 참석자의 의사전달시간이라고 한다.

위원회에서 모든 참석자들의 의사전달시간 중 최댓값이 최소가 되도록 대표를 정하는 프로그램을 작성하시오.

예를 들어 1번, 2번, 3번 세 사람으로 구성되어 있는 위원회에서 1번과 2번, 2번과 3번이 서로 알고 있다고 하자.

1번이 대표가 되면 3번이 대표인 1번에게 의견을 전달하기 위해서 2번을 거쳐야만 한다.

반대로 3번이 대표가 되어도 1번이 대표인 3번에게 의견을 전달하려면 2번을 거쳐야만 한다.

하지만 2번이 대표가 되면 1번과 3번 둘 다 아무도 거치지 않고 대표에게 직접 의견을 전달 할 수 있다.

따라서 이와 같은 경우 2번이 대표가 되어야 한다.

입력

첫째 중에 회의에 참석하는 사람의 수 N이 주어진다.

참석자들은 1부터 N까지의 자연수로 표현되며 회의에 참석하는 인원은 100 이하이다.

둘째 줄에는 서로 알고 있는 관계의 수 M이 주어진다.

이어 M개의 각 줄에는 서로 아는 사이인 참석자를 나타내는 두개의 자연수가 주어진다.

출력

첫째 줄에는 구성되는 위원회의 수 K를 출력한다.

다음 K줄에는 각 위원회의 대표 번호를 작은 수부터 차례로 한 줄에 하나씩 출력한다.

한 위원회의 대표가 될 수 있는 사람이 둘 이상일 경우 그중 한 명만 출력하면 된다.

예제 입력 1

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

예제 출력 1

3
2
4
8

추가 반례

예제 입력 A

100
0

예제 출력 A

100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

예제 입력 B

9
8
1 2
2 3
3 4
4 5
4 6
4 7
4 8
4 9

예제 출력 B

1
3

예제 입력 C

5
4
5 1
1 2
2 3
3 4

예제 출력 C

1
2

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2004 > 중등부 3번

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

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

알고리즘 분류

• 자료 구조
• 그래프 이론
• 그래프 탐색
• 분리 집합
• 플로이드–워셜

통과된 코드

Floyd-Warshall 알고리즘을 이용하여 의사전달 시간의 최솟값을 구한다.

그 후에 Union-Find를 이용하여 위원회의 개수와 대표를 구하면 된다.

(분리 집합 + 플로이드 와샬 문제)

#include <iostream>
#include <vector>
#include <set>

using namespace std;

// N : 참석하는 사람
int N, K, f, b;

constexpr int INF = INT32_MAX/2;

constexpr int MAX = 101;

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

int disArr[MAX][MAX];

int sumArr[MAX];

// 유니온 root노드 배열
int uArr[MAX];

set<int> checkSet;

//부모를 찾는 함수
//모든 경로가 부모를 가르키게 함
//상수 시간의 복잡도
int Find(int x)
{
	if (uArr[x] == x) return x;
	else return uArr[x] = Find(uArr[x]);
}

//두 노드를 연결 시키는 것
//기준을 정해서 연결시키는 것이 헷갈리지 않음
//작은쪽이 부모 or 큰쪽이 부모
void Union(int x, int y)
{
	x = Find(x);
	y = Find(y);
	if (x != y) {
		if (sumArr[x] <= sumArr[y]) uArr[y] = x;
		else uArr[x] = y;
	}
}

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

	cin >> N >> K;

	// 유니온 배열 초기화
	for (int i = 1; i <= N; i++) uArr[i] = i;

	// 서로를 알고 있음(양방향)
	for (int i = 0; i < K; i++) {
		cin >> f >> b;
		graph[f].push_back(make_pair(b, 1));
		graph[b].push_back(make_pair(f, 1));
	}

	// 최단 거리 배열 disArr 배열을 INF 초기화
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			disArr[i][j] = INF;
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 0; j < graph[i].size(); j++) {
			int v = graph[i][j].first;
			int weight = graph[i][j].second;
			disArr[i][v] = weight;
		}
	}

	// Floyd-Warshall 알고리즘
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {
				if (i == j) disArr[i][j] = 0;
				else disArr[i][j] = min(disArr[i][j], disArr[i][k] + disArr[k][j]);
			}
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			
			if (disArr[i][j] == INF) continue;
			// 의사전달시간 중 최대값이 최소가 되도록 대표를 선출
			sumArr[i] = max(sumArr[i], disArr[i][j]); 
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 0; j < graph[i].size(); j++) {
			// Union Find를 사용하여 위원회를 구성
			Union(i, graph[i][j].first);
		}
	}

	// 결과를 출력
	// Set을 이용하여 위원회의 개수와 대표를 저장
	for (int i = 1; i <= N; i++) checkSet.insert(Find(i));
	
	cout << checkSet.size() << "\n";
	for (auto& it : checkSet) cout << it << "\n";

	return 0;
}

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

집합의 표현

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

문제

초기에 n+1개의 집합 {0}, {1}, {2}, … , {n}이 있다.

여기에 합집합 연산과, 두 원소가 같은 집합에 포함되어 있는지를 확인하는 연산을 수행하려고 한다.

집합을 표현하는 프로그램을 작성하시오.

입력

첫째 줄에 n, m이 주어진다.

m은 입력으로 주어지는 연산의 개수이다.

다음 m개의 줄에는 각각의 연산이 주어진다.

합집합은 0 a b의 형태로 입력이 주어진다.

이는 a가 포함되어 있는 집합과, b가 포함되어 있는 집합을 합친다는 의미이다.

두 원소가 같은 집합에 포함되어 있는지를 확인하는 연산은 1 a b의 형태로 입력이 주어진다.

이는 a와 b가 같은 집합에 포함되어 있는 지를 확인하는 연산이다.

출력

1로 시작하는 입력에 대해서 a와 b가 같은 집합에 포함되어 있으면 “YES” 또는 “yes“를,

그렇지 않다면 “NO” 또는 “no“를 한 줄에 하나씩 출력한다.

제한

• 1 ≤ n ≤ 1,000,000 
• 1 ≤ m ≤ 100,000 
• 0 ≤ a, b ≤ n 
• a, b는 정수
• a와 b는 같을 수도 있다.

예제 입력 1

7 8
0 1 3
1 1 7
0 7 6
1 7 1
0 3 7
0 4 2
0 1 1
1 1 1

예제 출력 1

NO
NO
YES

출처

• 잘못된 데이터를 찾은 사람: Apple_Cplus
• 문제를 번역한 사람: author5
• 데이터를 추가한 사람: njw1204

알고리즘 분류

• 자료 구조
• 분리 집합

접근 방법

통과된 코드

#include <iostream>

using namespace std;

constexpr int Max = 1000001;

// 유니온 root노드 배열
int uArr[Max];

int N, M, u, b, c;

//부모를 찾는 함수
//모든 경로가 부모를 가르키게 함
//상수 시간의 복잡도
int Find(int x)
{
    if (uArr[x] == x) return x;
    return uArr[x] = Find(uArr[x]);
}

//두 노드를 연결 시키는 것
//기준을 정해서 연결시키는 것이 헷갈리지 않음
//작은쪽이 부모 or 큰쪽이 부모
void Union(int x, int y)
{
    x = Find(x);
    y = Find(y);

    if (x != y) {
        if (x < y) uArr[y] = x;
        else uArr[x] = y;
    }
}

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 = 0; i <= N; i++) uArr[i] = i;

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

        cin >> u >> b >> c;

        if (u == 0) { // 합집합 연산
            Union(b, c);
        }
        else { // 질의
            if (Find(b) != Find(c)) cout << "NO\n";
            else cout << "YES\n";
        }
    }

    return 0;
}

The post 백준 1717번 (집합의 표현, C++, Union-Find) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.