๋ฌธ์
[์ฌ์ดํด ๊ฒ์ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ]
์ฌ์ดํด ๊ฒ์์ ๋ ๋ช ์ ํ๋ ์ด์ด๊ฐ ์ฐจ๋ก๋๋ก ๋์๊ฐ๋ฉฐ ์งํํ๋ ๊ฒ์์ผ๋ก, ์ ํ๋ ์ด์ด๊ฐ ํ์ ๋ฒ์งธ ์ฐจ๋ก๋ฅผ, ํ ํ๋ ์ด์ด๊ฐ ์ง์ ๋ฒ์งธ ์ฐจ๋ก๋ฅผ ์งํํ๋ค. ๊ฒ์ ์์ ์ 0 ๋ถํฐ n − 1 ๊น์ง ๊ณ ์ ํ ๋ฒํธ๊ฐ ๋ถ์ฌ๋ ํ๋ฉด ์์ ์ n ๊ฐ๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ์ค ์ด๋ ์ธ ์ ๋ ์ผ์ง์ ์์ ๋์ด์ง ์๋๋ค. ๋งค ์ฐจ๋ก ๋ง๋ค ํ๋ ์ด์ด๋ ๋ ์ ์ ์ ํํด์ ์ด๋ฅผ ์ฐ๊ฒฐํ๋ ์ ๋ถ์ ๊ธ๋๋ฐ, ์ด์ ์ ๊ทธ๋ฆฐ ์ ๋ถ์ ๋ค์ ๊ทธ์ ์๋ ์์ง๋ง ์ด๋ฏธ ๊ทธ๋ฆฐ ๋ค๋ฅธ ์ ๋ถ๊ณผ ๊ต์ฐจํ๋ ๊ฒ์ ๊ฐ๋ฅํ๋ค. ๊ฒ์์ ์งํํ๋ค๊ฐ ์ฒ์์ผ๋ก ์ฌ์ดํด์ ์์ฑํ๋ ์๊ฐ ๊ฒ์์ด ์ข ๋ฃ๋๋ค. ์ฌ์ดํด C๋ ํ๋ ์ด์ด๊ฐ ๊ทธ๋ฆฐ ์ ๋ถ๋ค์ ๋ถ๋ถ์งํฉ์ผ๋ก, ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
์ ๋ ฅ์ผ๋ก ์ ์ ๊ฐ์ n๊ณผ m ๋ฒ์งธ ์ฐจ๋ก๊น์ง์ ๊ฒ์ ์งํ ์ํฉ์ด ์ฃผ์ด์ง๋ฉด ์ฌ์ดํด์ด ์์ฑ ๋์๋์ง๋ฅผ ํ๋จํ๊ณ , ์์ฑ๋์๋ค๋ฉด ๋ช ๋ฒ์งธ ์ฐจ๋ก์์ ์ฒ์์ผ๋ก ์ฌ์ดํด์ด ์์ฑ๋ ๊ฒ์ธ์ง๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ์ด
๊ฒฐ๊ตญ ์ฌ์ดํด์ธ์ง๋ฅผ ํ์ํ๋ ๋ฐฉ๋ฒ์ ์๊ฐ๋ณต์ก๋๊ฐ ์ค์ํ๋ค. m๋ฒ์ ์ฐจ๋ก๋ ์ด์ฐจํผ ์ดํด๋ณด์์ผ ํ๋ 1,000,000(10^6) ์๊ฐ๋ณต์ก๋์ ๋ฐ๋ณต๋ฌธ์ ๋๊ฒ ๋๋๋ฐ ์๊ฐ๋ณต์ก๋๊ฐ ๋์ง ์๊ธฐ ์ํด์๋ ๋ด๋ถ์ 10^3 ์ด์์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์๊ณ ๋ฆฌ์ฆ์ด ์์ผ๋ฉด ์๋๋ค.๋ด๋ถ์์๋ ์ฌ์ดํด์ด ์กด์ฌํ๋ ์ง๋ฅผ ํ๋จํด์ผํ๋๋ฐ ๊ทธ ๋ฐฉ๋ฒ์ ๋ค์ 3๊ฐ์ง๊ฐ ์๋ค. (๋ ธ๋์ ์ด ๊ฐ์๋ฅผ n์ด๋ผ๊ณ ํ์.)
- dfs๋ก ํ๋จ : edge๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค node๋ฅผ dfsํ์ฌ ๊ฐ์ node๊ฐ ๋์ค๋ ์ง ์ฒดํฌํ๋ค. ์๊ฐ๋ณต์ก๋๋ O(n)์ด๋ค.
- ์งํฉ์ผ๋ก ํ๋จ : edge๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค ์ด์ด์ง node๋ค์ ๊ฐ์ ์งํฉ์ ๋ฃ๋๋ค(๊ตณ์ด ๋ฃ์ ํ์์์ด ๊ฐ์ ์งํฉ์ด๋ผ๊ณ ํ์ํ๋ค). ์ด ๋, ์ด๋ฏธ node๊ฐ ํด๋น ์งํฉ์ ์๋ ์ง ์ฒดํฌํ๋ค. ์๊ฐ๋ณต์ก๋๋ O(n)์ด๋ค.
- union-find : ๋ถ๋ชจ node๋ฅผ ์ ์ฅํด๋์๋ค๊ฐ ์๋ก ์ถ๊ฐ๋ edge์ ๋ node๊ฐ ๊ฐ์ parent๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ์ฒดํฌํ๋ค. ์๊ฐ๋ณต์ก๋๋ O(lgn)์ด๋ค.
๋ฐ๋ผ์ 3๋ฒ์งธ ๋ฐฉ๋ฒ์ธ union-find๋ฅผ ์ ์ฉํด์ผ n์ ๋ฒ์์ธ 500,000(10^5)๋ฅผ ๊ฐ๋นํ ์ ์๋ค.
์ฝ๋
#include <iostream>
#include <vector>
using namespace std;
vector<int> parentList;
int parent(int idx){
if(parentList[idx] == idx){
return idx;
}
return parentList[idx] = parent(parentList[idx]);
}
bool unionGroup(int c, int p){
int parentC = parent(c);
int parentP = parent(p);
if(parentC == parentP){
// ์ฌ์ดํด
return false;
}
parentList[parentC] = parentP;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, M; cin >> N >> M;
for(int i=0; i<N; i++){
parentList.push_back(i);
}
int res = 0;
for(int i=0; i<M; i++){
int c,p; cin >> c >> p;
if(!unionGroup(c, p)){
res = i+1;
break;
}
}
cout << res;
}
๊ฒฐ๊ณผ
'Algorithm ๋ฌธ์ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] BOJ 14906 :: ์ค๋ฌํผ(Slurpys) (0) | 2021.11.03 |
---|---|
[c++] BOJ 1013 :: Contact (0) | 2021.10.17 |
[c++] BOJ 7579 :: ์ฑ (0) | 2021.10.10 |
[c++] BOJ 1501 :: ์์ด ์ฝ๊ธฐ (0) | 2021.10.07 |
[c++] BOJ 1253 :: ์ข๋ค (0) | 2021.09.28 |
Comment