๐ Algorithm
[์ฝ๋ฉ ํ ์คํธ ํฉ๊ฒฉ์ ๋๊ธฐ ๋ฌธ์ 33] ๊ฐ๋จํ ์ ๋์จ-ํ์ธ๋ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํํ๊ธฐ
s2ylvia
2024. 9. 11. 18:49
๋ฌธ์ ์ค๋ช
์ํธ๋ฐฐํ์ ์งํฉ์ ํํํ๊ณ ๊ด๋ฆฌํ๋ ๋ฐ ๋ค์ ๋ ์ฐ์ฐ์ด ํ์ํฉ๋๋ค.
- union(x,y) : x์ y๊ฐ ์ํ ๋ ์งํฉ์ ํฉ์นฉ๋๋ค.
- find(x,y) : x๊ฐ ์ํ ์งํฉ์ ๋ํ ์์๋ฅผ ์ฐพ์ต๋๋ค.
operations๋ผ๋ ๋ฐฐ์ด์ ์ํํ ์ฐ์ฐ์ ์๋ฏธํฉ๋๋ค. ์ฐ์ฐ ์ข ๋ฅ๋ 2๊ฐ์ ๋๋ค.
- ['u',1,2]๋ ๋ ธ๋ 1๊ณผ ๋ ธ๋ 2์ ๋ํด union ์ฐ์ฐ ์ํ
- ['f',3]๋ ๋ ธ๋ 3์ ๋ฃจํธ ๋ ธ๋ ์ฐพ๊ธฐ, find ์ฐ์ฐ ์ํ
์ด๊ธฐ์ ๋ ธ๋๋ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์์ ์ ๊ฐ์ผ๋ก ์ค์ ํ๋ค๊ณ ๊ฐ์ ํ๋ฉฐ, ์ฌ๊ธฐ์๋ ๊ฐ ์งํฉ์ ๋ฃจํธ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฃจํธ ๋ ธ๋๊ฐ ์์ ๋ ธ๋๋ฅผ ๋ ํฐ ๋ ธ๋์ ์์์ผ๋ก ์ฐ๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํฉ๋๋ค. operations์ ์๋ ์ฐ์ฐ์ ๋ชจ๋ ์ํํ ํ ์งํฉ์ ๊ฐ์๋ฅผ ๋ฐํํ๋ solution() ํจ์๋ฅผ ๊ตฌํํด์ฃผ์ธ์.
์ ์ฝ ์กฐ๊ฑด
- 0 <= k <= 1000 : ๋ ธ๋์ ๊ฐ์
- 1 <= operations <= 100000
- operations[i][0]์ ๋ฌธ์์ด 'u' ๋๋ 'f' ์ค ํ๋
- 'u'๋ union ์ฐ์ฐ, union ์ฐ์ฐ ๋ค๋ก๋ ๋ ๊ฐ์ ์ ์ x,y๊ฐ ๋์ด
- 'f'๋ find ์ฐ์ฐ, find ์ฐ์ฐ ๋ค๋ก๋ ํ๋์ ์ ์ x๊ฐ ๋์ด
- x์ y๋ 0 ์ด์ k-1 ์ดํ์ ์ ์
- ์ฐ์ฐ์ ํญ์ ์ ํจํจ
- ์ฆ, union, find ์ฐ์ฐ์ ์ธ์๋ ์ํธ๋ฐฐํ์ ์งํฉ ๋ด์ ์๋ ๋ ธ๋ ๋ฒํธ
์ ์ถ๋ ฅ์ ์
k | operations | result |
3 | [['u', 0, 1], ['u',1, 2],['f', 2] | 1 |
4 | [['u', 0, 1], ['u',2, 3],['f', 0] | 2 |
์ ๋ต
const find = (parents, x) => {
//๋ฃจํธ ๋
ธ๋๋ฅผ ์ฐพ๋ ๊ฒ
if(parents[x] === x){
//parents[x]๊ฐ x์ ๋ถ๋ชจ ๋
ธ๋๋๊น ๊ฐ์ผ๋ฉด ๋ฃจํธ ๋
ธ๋๋ฅผ ์ฐพ์๊ฑฐ๋๊น
return x;
}
parents[x] = find(parents, parents[x]); //๋ถ๋ชจ ๋
ธ๋์ ๋ถ๋ชจ ๋
ธ๋์ ๋ถ๋ชจ ๋
ธ๋์...
//์ฌ๊ท๋ก ์ฐพ์๋ธ๋ค
return parents[x];
}
const union = (parents, x, y) = {
//ํฉ์น๋๊ฑฐ => ๋ฃจํธ ๋
ธ๋๋ฅผ ๊ฐ๊ฒ ํ๋๊ฒ
//์ฐ์ ๋ฃจํธ ๋
ธ๋๋ฅผ ์ฐพ๊ณ ํฉ์น๋ฉด ๋๋ค
const root1 = find(parents, x);
const root2 = find(parents, y);
parents[root2] = root1; //x๊ฐ ์ํ ์งํฉ์ ๋ฃจํธ ๋
ธ๋๋ ๊ฐ๊ฒ ํ๋๊ฑฐ๋๊น y๊ฐ x์ ๋ถ์
}
const solution = (k, operations) => {
//์๊ธฐ๋ฅผ ๋ฃจํธ ๋
ธ๋๋ก ์ด๊ธฐํ
//[0,1,2]
const parents = Array.from({length: k}, (_,i) => i);
let n = k; //์งํฉ์ ๊ฐ์, ์ง๊ธ์ ๋ค ๋ค๋ฅธ ์งํฉ์ด๋๊น(๋ฃจํธ ๋
ธ๋๊ฐ ๋ค๋ฅด๋๊น) k๊ฐ
for(const op of operations){
if(op[0] === 'u'){
union(parents, op[1], op[2]);
}else if(op[1] === 'f'){
find(parents, op[1]);
}
}
//๋ฃจํธ ๋
ธ๋์ ๊ฐฏ์๊ฐ ๊ณง ์งํฉ์ ๊ฐฏ์
n = new Set(Array.from({length: k}, (_,i) => find(parents,i))).size;
return n;
}