- ์ฌ๊ท
- golang
- ์นด์นด์ค ์ฝํ
- BFS
- ๋นํธ๋ง์คํน
- ๋นํธ๋งต
- go
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- js
- Python
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- nestjs
- ์น๋ฆฐ์ด
- DP
- Union-Find
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- C++
- LCs
- ์ํฐ๋
- ํธ๋ฆฌ
- ํ๋ฆฌ์จ๋ณด๋ฉ
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- DFS
- ๋ฐฑ์ค
- ํ๋ก๊ทธ๋๋จธ์ค
- ์นด์นด์ค2021
- ์ด๋ถํ์
- ๋ค์ต์คํธ๋ผ
- ์๊ณ ๋ฆฌ์ฆ
- ์์ฝ๋
- Today
- Total
Hello Ocean! ๐ผ
[๋ฐฑ์ค/Python] 20040. ์ฌ์ดํด ๊ฒ์ ๋ณธ๋ฌธ
๋ฌธ์
https://www.acmicpc.net/problem/20040
์ฌ์ดํด ๊ฒ์์ ๋ ๋ช ์ ํ๋ ์ด์ด๊ฐ ์ฐจ๋ก๋๋ก ๋์๊ฐ๋ฉฐ ์งํํ๋ ๊ฒ์์ผ๋ก, ์ ํ๋ ์ด์ด๊ฐ ํ์ ๋ฒ์งธ ์ฐจ๋ก๋ฅผ, ํ ํ๋ ์ด์ด๊ฐ ์ง์ ๋ฒ์งธ ์ฐจ๋ก๋ฅผ ์งํํ๋ค. ๊ฒ์ ์์ ์ 0 ๋ถํฐ n โ 1 ๊น์ง ๊ณ ์ ํ ๋ฒํธ๊ฐ ๋ถ์ฌ๋ ํ๋ฉด ์์ ์ n ๊ฐ๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ์ค ์ด๋ ์ธ ์ ๋ ์ผ์ง์ ์์ ๋์ด์ง ์๋๋ค. ๋งค ์ฐจ๋ก ๋ง๋ค ํ๋ ์ด์ด๋ ๋ ์ ์ ์ ํํด์ ์ด๋ฅผ ์ฐ๊ฒฐํ๋ ์ ๋ถ์ ๊ธ๋๋ฐ, ์ด์ ์ ๊ทธ๋ฆฐ ์ ๋ถ์ ๋ค์ ๊ทธ์ ์๋ ์์ง๋ง ์ด๋ฏธ ๊ทธ๋ฆฐ ๋ค๋ฅธ ์ ๋ถ๊ณผ ๊ต์ฐจํ๋ ๊ฒ์ ๊ฐ๋ฅํ๋ค. ๊ฒ์์ ์งํํ๋ค๊ฐ ์ฒ์์ผ๋ก ์ฌ์ดํด์ ์์ฑํ๋ ์๊ฐ ๊ฒ์์ด ์ข ๋ฃ๋๋ค. ์ฌ์ดํด C๋ ํ๋ ์ด์ด๊ฐ ๊ทธ๋ฆฐ ์ ๋ถ๋ค์ ๋ถ๋ถ์งํฉ์ผ๋ก, ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
C์ ์ํ ์์์ ์ ๋ถ์ ํ ๋์ ์์ ์ถ๋ฐํ์ฌ ๋ชจ๋ ์ ๋ถ์ ํ ๋ฒ์ฉ๋ง ์ง๋์ ์ถ๋ฐ์ ์ผ๋ก ๋๋์์ฌ ์ ์๋ค.
๋ฌธ์ ๋ ์ ๋ถ์ ์ฌ๋ฌ ๊ฐ ๊ทธ๋ฆฌ๋ค ๋ณด๋ฉด ์ฌ์ดํด์ด ์์ฑ ๋์๋์ง์ ์ฌ๋ถ๋ฅผ ํ๋จํ๊ธฐ ์ด๋ ค์ ์ด๋ฏธ ์ฌ์ดํด์ด ์์ฑ๋์์์๋ ๋ถ๊ตฌํ๊ณ ๊ฒ์์ ๊ณ์ ์งํํ๊ฒ ๋ ์ ์๋ค๋ ๊ฒ์ด๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ๊ฒ์์ ์งํ ์ํฉ์ด ์ฃผ์ด์ง๋ฉด ๋ช ๋ฒ์งธ ์ฐจ๋ก์์ ์ฌ์ดํด์ด ์์ฑ๋์๋์ง, ํน์ ์์ง ๊ฒ์์ด ์งํ ์ค์ธ์ง๋ฅผ ํ๋จํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ ค ํ๋ค.
์ ๋ ฅ์ผ๋ก ์ ์ ๊ฐ์ n๊ณผ m ๋ฒ์งธ ์ฐจ๋ก๊น์ง์ ๊ฒ์ ์งํ ์ํฉ์ด ์ฃผ์ด์ง๋ฉด ์ฌ์ดํด์ด ์์ฑ ๋์๋์ง๋ฅผ ํ๋จํ๊ณ , ์์ฑ๋์๋ค๋ฉด ๋ช ๋ฒ์งธ ์ฐจ๋ก์์ ์ฒ์์ผ๋ก ์ฌ์ดํด์ด ์์ฑ๋ ๊ฒ์ธ์ง๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ ๋ ฅ์ ํ์ค์ ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ์ ์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ 3 โค n โค 500,000 ๊ณผ ์งํ๋ ์ฐจ๋ก์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ 3 โค m โค 1,000,000 ์ด ์ฃผ์ด์ง๋ค. ๊ฒ์์์ ์ฌ์ฉํ๋ n๊ฐ์ ์ ์๋ 0 ๋ถํฐ n โ 1 ๊น์ง ๊ณ ์ ํ ๋ฒํธ๊ฐ ๋ถ์ฌ๋์ด ์์ผ๋ฉฐ, ์ด ์ค ์ด๋ ์ธ ์ ๋ ์ผ์ง์ ์์ ๋์ด์ง ์๋๋ค. ์ด์ด์ง๋ m ๊ฐ์ ์ ๋ ฅ ์ค์๋ ๊ฐ๊ฐ i๋ฒ์งธ ์ฐจ๋ก์ ํด๋น ํ๋ ์ด์ด๊ฐ ์ ํํ ๋ ์ ์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค (1 โค i โค m).
์ถ๋ ฅ
์ถ๋ ฅ์ ํ์ค์ถ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์ผ์ด์ค์ ๋ํด, m ๋ฒ์งธ ์ฐจ๋ก๊น์ง ๊ฒ์์ ์งํํ ์ํฉ์์ ์ด๋ฏธ ๊ฒ์์ด ์ข ๋ฃ๋์๋ค๋ฉด ์ฌ์ดํด์ด ์ฒ์์ผ๋ก ๋ง๋ค์ด์ง ์ฐจ๋ก์ ๋ฒํธ๋ฅผ ์์ ์ ์๋ก ์ถ๋ ฅํ๊ณ , m ๋ฒ์ ์ฐจ๋ก๋ฅผ ๋ชจ๋ ์ฒ๋ฆฌํ ์ดํ์๋ ์ข ๋ฃ๋์ง ์์๋ค๋ฉด 0์ ์ถ๋ ฅํ๋ค.
ํ์ด
Union - Find ์๊ณ ๋ฆฌ์ฆ์ ๋ถ๋ชจ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์์ผ๋ก ํธ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ์๋ค.
์ถ๊ฐ๋ก size๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ, ๋ ํธ๋ฆฌ๋ฅผ ๋จธ์งํ ๋ size๊ฐ ์์ ์ชฝ์ ํฐ ์ชฝ ๋ฐ์ ๋ฌ์์ฃผ์๋ค.
size[i] : i ๋ ธ๋์ ์์ ์
์ฝ๋
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
# ๋ถ๋ชจ๋ฅผ ๋ํ๋ด๋ ๋ฐฐ์ด
parent = [i for i in range(N)]
size = [1 for i in range(N)]
def find(n):
if (parent[n] == n):
return n
else:
parent[n] = find(parent[n])
return parent[n]
def union(a, b):
a = find(a)
b = find(b)
if size[a] > size[b]: # a๋ฐ์ b๋ฅผ ๋ฌ์์ค๋ค = b์ ๋ถ๋ชจ๋ฅผ a๋ก ์ค์
parent[b] = a
size[a] += size[b]
else: # b ๋ฐ์ a๋ฅผ ๋ฌ์์ค๋ค = a์ ๋ถ๋ชจ๋ฅผ b๋ก ์ค์
parent[a] = b
size[b] += size[a]
sys.setrecursionlimit(10 ** 9)
isDone = False
for m in range(1,M+1):
a, b = map(int, input().split())
if find(a) == find(b):
print(m)
isDone = True
break
union(a,b)
if not isDone:
print(0)
๊ฒฐ๊ณผ

์ฐธ๊ณ

python์ด ์๊ฐ์ด ์ค๋ ๊ฑธ๋ ค์ ๊ทธ๋ฐ์ง,
์๊ณ ๋ฆฌ์ฆ์ ์ง์ ๋์ผํ๋๋ฐ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด ์์ํ ๊ฒ๋ค์ ์ถ๊ฐํด์ผํ๋ค.
1. sys.setrecursionlimit(10 ** 9) ์ถ๊ฐ
์ฌ๊ท ํจ์ ๊น์ด๋ฅผ ์ ํํด์ ์๊ฐ์ ์ค์ผ ์ ์๋ ์ฝ๋์ด๋ค.
2. find(a) == find(b) ๋ฅผ unionํจ์ ๋ด์์ ํ๊ณ ์ถ์๋๋ฐ, ์๊ฐ์ด๊ณผ๋ก ์ธํด ๋ฐ์ผ๋ก ๋นผ์ผํ๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/C++] 1013. Contact (0) | 2021.10.26 |
---|---|
[๋ฐฑ์ค/Python] 7579. ์ฑ (0) | 2021.10.12 |
[CS/์๊ณ ๋ฆฌ์ฆ] ๊ฑฐ์ ์ ๋ ฌ๋ List์์ ์ด๋ค ์ ๋ ฌ์ด ๊ฐ์ฅ ํจ์จ์ ์ผ๊น? (0) | 2021.10.09 |
[CS/์๋ฃ๊ตฌ์กฐ] ์ด์ง ํ์ ํธ๋ฆฌ (BST) (0) | 2021.10.09 |
[๋ฐฑ์ค/Python] 1501. ์์ด ์ฝ๊ธฐ (1) | 2021.10.06 |