๋ฌธ์
์น๊ตฌ ๋คํธ์ํฌ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๋ฏผํ์ด๋ ์์ ๋คํธ์ํฌ ์ฌ์ดํธ์์ ์น๊ตฌ๋ฅผ ๋ง๋๋ ๊ฒ์ ์ข์ํ๋ ์น๊ตฌ์ด๋ค. ์ฐํ๋ฅผ ๋ชจ์ผ๋ ์ทจ๋ฏธ๊ฐ ์๋ฏ์ด, ๋ฏผํ์ด๋ ์์ ๋คํธ์ํฌ ์ฌ์ดํธ์์ ์น๊ตฌ๋ฅผ ๋ชจ์ผ๋ ๊ฒ์ด ์ทจ๋ฏธ์ด๋ค.
์ด๋ค ์ฌ์ดํธ์ ์น๊ตฌ ๊ด๊ณ๊ฐ ์๊ธด ์์๋๋ก ์ฃผ์ด์ก์ ๋, ๋ ์ฌ๋์ ์น๊ตฌ ๋คํธ์ํฌ์ ๋ช ๋ช ์ด ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์น๊ตฌ ๋คํธ์ํฌ๋ ์น๊ตฌ ๊ด๊ณ๋ง์ผ๋ก ์ด๋ํ ์ ์๋ ์ฌ์ด๋ฅผ ๋งํ๋ค.
ํ์ด
ํน์ ์ด๋ฆ์ด ์ฃผ์ด์ก์ ๋ ํด๋น ์ด๋ฆ์ด ์ํ ๊ทธ๋ฃน์ ์ ์ ์์ด์ผ ํ๊ณ , ํด๋น ๊ทธ๋ฃน์ ์๋ ์ด๋ฆ์ ๊ฐ์๋ฅผ ํ์ ํ ์ ์์ด์ผ ํ๋ ๋ฌธ์ ์ด๋ค.
์ด๋ฆ์ด ์ํ ๊ทธ๋ฃน์ ๋ฐ๋ก ์ฐพ๊ธฐ ์ํด์๋ map<string, int>
๋ฅผ ์ด์ฉํ ์ ์์ผ๋ฉฐ ํด๋น ๊ทธ๋ฃน์ ์๋ ์ด๋ฆ์ ๊ฐ์๋ฅผ ํ์
ํ๊ธฐ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค.
set<string> group[n]
์ผ๋ก ํน์ idx ๊ทธ๋ฃน์ ์ํ๋ ๋ชจ๋ ์ด๋ฆ์ ์ ์ฅํด๋ ์ ์๋ค.- ๋ค๋ฅธ set๋ค์ ๊ด๊ณ๋ก ํํํ ์ ์๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ์ ๋ ฅ์ด ์ฃผ์ด์ก๋ค๊ณ ํ์.
1
5
a b // ๊ทธ๋ฃน 1: a b
b c // ๊ทธ๋ฃน 1: a b c
c a // ๊ทธ๋ฃน 1: a b c
i j // ๊ทธ๋ฃน 1: a b c, ๊ทธ๋ฃน 2: i j
j a // ๊ทธ๋ฃน 1: a b c i j
1๋ฒ์ ๋ฐฉ์์ผ๋ก ํ๋ฉด j a
์
๋ ฅ์ด ๋ค์ด์์ ๋
- ๊ธฐ์กด์ ๊ทธ๋ฃน 1์ ๊ทธ๋ฃน 2์ ์์๋ฅผ ๋ชจ๋ ๋ฃ์ด ์ฃผ์ด์ผ ํ๋ค.
- ๋ํ, ๊ทธ๋ฃน 1๋ก ํฉ์ณ์ก๋ค๋ ์ฌ์ค์ ํํํ๊ธฐ ์ํด i์ j์ ๋ํด์๋
map[i] = map[j] = 1;
๋ก ์์ ํ ์ ์์ง๋ง ๊ฐ์ ๊ทธ๋ฃน์ ์ํ๋ ๋ชจ๋ ์์์ ๋ํด์ map์ ์์ ํด์ฃผ์ด์ผ ํ๋ค.
์ฒซ๋ฒ์งธ ๋ฌธ์ ์ ์ ์ด์ฐจํผ ๊ทธ๋ฃน์ ์ฌ์ด์ฆ๋ง์ ๋ฌป๋ ๋ฌธ์ ์ ํน์ฑ์ ์ด์ฉํ์ฌ set์ด ์๋ int ํ์ผ๋ก ๋ฐ๊ฟ์ ์ซ์๋ง ๋ํด์ฃผ๋ ์์ผ๋ก ๊ฐ์ ํ ์ ์๋ค.
๋๋ฒ์งธ ๋ฌธ์ ์ ์ ๊ฐ์ ๊ทธ๋ฃน์ ์ํ๋ ๋ชจ๋ ์์์ ๋ํด map์ ์์ ํ๊ธฐ๋ณด๋ค parent๋ผ๋ ๋ฐฐ์ด์ ํ๋ ๋ ๋ง๋ค์ด์ ๊ทธ๋ฃน ๊ฐ์ ๊ด๊ณ๋ฅผ ํํํด์ค์ผ๋ก์จ ํด๊ฒฐํ ์ ์๋ค. ์์ ์ํฉ์์ parent[2] = 1;
์ผ๋ก ํํํ๋ ๊ฒ์ด๋ค.
๊ฒฐ๊ตญ j a
์
๋ ฅ์ด ๋ค์ด์์ ๋, j๊ฐ ์ํ ๊ทธ๋ฃน์ ์ต์์ ๋ถ๋ชจ๋ฅผ ์ฐพ๊ณ (2) a๊ฐ ์ํ ๊ทธ๋ฃน์ ์ต์์ ๋ถ๋ชจ(1)๋ฅผ ์ฐพ์์ ๋ ๊ทธ๋ฃน์ ํฉ์น ๋ค ๋๋จธ์ง ํ ๊ทธ๋ฃน์ ๋ถ๋ชจ๋ฅผ ํด๋น ๊ทธ๋ฃน์ผ๋ก ํ ๋นํด์ฃผ๋ฉด ๋๋ค.
์ฒ์ ๊ทธ๋ฃน์ ์์ฑ๋ ๋์ ๊ฐ์ด ๊ณ ๋ คํด์ผํ๋ ์ฌํญ ๋ ์์ง๋ง ์ฝ๋๋ก ์ดํด๋ณด์.
์ฝ๋
#include <iostream>
#include <string>
#include <map>
#include <set>
#include <algorithm>
using namespace std;
map<string, int> friendMap; // ๊ฐ ์ด๋ฆ์ด ์ํ ๊ทธ๋ฃน
int friendGroup[100001] = { 1, 0, }; // ํด๋น ๊ทธ๋ฃน์ ์์ ์
int parent[100001]; // ๊ฐ ๊ทธ๋ฃน์ ๋ถ๋ชจ
int groupSize = 1;
int findParent(int chlidGroup) { // find parent
if (parent[chlidGroup] == chlidGroup) {
// ์ต์์ ๋ถ๋ชจ์ด๋ฉด
return chlidGroup;
}
return findParent(parent[chlidGroup]);
}
int unionGroup(int group1, int group2) {
int parentGroup = max(group1, group2);
int childGroup = min(group1, group2);
friendGroup[parentGroup] += friendGroup[childGroup];
if (childGroup != 0) {
parent[childGroup] = parentGroup;
}
return parentGroup;
}
int initGroup(int group) {
friendGroup[group] = 2;
parent[group] = group; // ์ฒ์์ ์๊ธฐ ์์ ์ด ๋ถ๋ชจ
return group;
}
int main() {
ios::sync_with_stdio(false); cout.tie(NULL); cin.tie(NULL);
int T; cin >> T;
while (T--) {
friendMap.clear();
int num; cin >> num;
while (num--) { // 10^5
string p1, p2;
cin >> p1 >> p2;
int p1Group = findParent(friendMap[p1]);
int p2Group = findParent(friendMap[p2]);
int group, anotherGroup;
if (p1Group == p2Group) { // ๊ฐ์ ๊ทธ๋ฃน์ ์ํด์์ผ๋ฉด
if (p1Group != 0) {
cout << friendGroup[p1Group] << '\n';
continue;
}
// ๋ ๋ค ์ฒ์์ด๋ฉด
group = initGroup(groupSize++);
}
else {
// ๋ค๋ฅด๋ฉด ํฉ์น๊ธฐ
group = unionGroup(p1Group, p2Group);
}
friendMap[p1] = friendMap[p2] = group;
cout << friendGroup[group] << '\n';
}
}
}
๊ฒฐ๊ณผ
๋ฌธ์ | ๋ฉ๋ชจ๋ฆฌ | ์๊ฐ | ์ฝ๋ ๊ธธ์ด |
---|---|---|---|
4195 | 18520 | 244 | 1904 |
'Algorithm ๋ฌธ์ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] BOJ 1501 :: ์์ด ์ฝ๊ธฐ (0) | 2021.10.07 |
---|---|
[c++] BOJ 1253 :: ์ข๋ค (0) | 2021.09.28 |
[c++] BOJ 5430 :: AC (0) | 2021.09.07 |
[c++] BOJ 14725 :: ๊ฐ๋ฏธ๊ตด (0) | 2021.09.07 |
[c++] BOJ 3108 :: ๋ก๊ณ (0) | 2021.08.31 |
Comment