https://www.acmicpc.net/problem/10775
๋ฌธ์
์ค๋์ ์ ์น์์ ์์ผ์ด๋ค.
๋ฐ์น์์ ์์ผ์ ๋ง์ ์ ์น์์๊ฒ ์ธ์ฒ๊ตญ์ ๊ณตํญ์ ์ ๋ฌผ๋ก ์คฌ๋ค.
๊ณตํญ์๋ G๊ฐ์ ๊ฒ์ดํธ๊ฐ ์์ผ๋ฉฐ ๊ฐ๊ฐ์ 1์์ G๊น์ง์ ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
๊ณตํญ์๋ P๊ฐ์ ๋นํ๊ธฐ๊ฐ ์์๋๋ก ๋์ฐฉํ ์์ ์ด๋ฉฐ, ๋น์ ์ i๋ฒ์งธ ๋นํ๊ธฐ๋ฅผ 1๋ฒ๋ถํฐ gi (1 โค gi โค G) ๋ฒ์งธ ๊ฒ์ดํธ์ค ํ๋์ ์๊ตฌ์ ์ผ๋ก ๋ํนํ๋ ค ํ๋ค. ๋นํ๊ธฐ๊ฐ ์ด๋ ๊ฒ์ดํธ์๋ ๋ํนํ ์ ์๋ค๋ฉด ๊ณตํญ์ด ํ์๋๊ณ , ์ดํ ์ด๋ค ๋นํ๊ธฐ๋ ๋์ฐฉํ ์ ์๋ค.
์ ์น์์ ๊ฐ์ฅ ๋ง์ ๋นํ๊ธฐ๋ฅผ ๊ณตํญ์ ๋ํน์์ผ์ ๋ฐ์น์์ ํ๋ณตํ๊ฒ ํ๊ณ ์ถ์ดํ๋ค. ์น์์ด๋ ๋นํ๊ธฐ๋ฅผ ์ต๋ ๋ช ๋ ๋ํน์ํฌ ์ ์๋๊ฐ?
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์๋ ๊ฒ์ดํธ์ ์ G (1 โค G โค 105)๊ฐ ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค์๋ ๋นํ๊ธฐ์ ์ P (1 โค P โค 105)๊ฐ ์ฃผ์ด์ง๋ค.
์ดํ P๊ฐ์ ์ค์ gi (1 โค gi โค G) ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์น์์ด๊ฐ ๋ํน์ํฌ ์ ์๋ ์ต๋์ ๋นํ๊ธฐ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ฝ๋
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
# ๋ํน ๊ฐ๋ฅํ ๊ฒ์ดํธ๋ฅผ ์ฐพ๋ ํจ์
def find(n):
# ์ฒ์ ์ฌ์ฉ๋๋ ๊ฒ์ดํธ์ธ ๊ฒฝ์ฐ
if root[n] == n:
return n
root[n] = find(root[n]) # ๊ฒ์ดํธ๋ฅผ ๊ณ์ ์์ ์ซ์๋ก ๋ฐ๊ฟ์ค
return root[n]
G = int(input())
P = int(input())
# ๊ฒ์ดํธ ์ ๋ณด๋ฅผ ์ ์ฅ
root = [i for i in range(G+1)]
# ๋นํ๊ธฐ ์ ๋ณด๋ฅผ ์ ์ฅ
plane = [int(input()) for _ in range(P)]
# ์ต๋๋ก ๋ํน ๊ฐ๋ฅํ ๋นํ๊ธฐ ์๋ฅผ ์ฐพ์์ค
res = 0
for p in plane:
# ์ด์ฉ๊ฐ๋ฅํ ๊ฒ์ดํธ๋ฅผ ์ฐพ์์ค
gate = find(p)
# ๋ ์ด์ ์ด์ฉ๊ฐ๋ฅํ ๊ฒ์ดํธ๊ฐ ์์ผ๋ฏ๋ก ํ์
if gate == 0:
break
# ๋นํ๊ธฐ ํ ๋๋ฅผ ๋์ผ๋ฏ๋ก -1
root[gate] -= 1
res += 1
print(res)
๋ณธ์ธ์ด ๋ฃจํธ ๋ ธ๋๋ผ๋ฉด, ์ด๋ ๊ณง ํด๋น ๊ฒ์ดํธ๋ฅผ ํ ๋ฒ๋ ์ฌ์ฉํ์ง ์์์์ ๋งํ๋ค.
๋ง์ฝ ๋ฃจํธ ๋ ธ๋๊ฐ ์๋๋ผ๋ฉด ์ฌ์ฉํ ์ ์ด ์๋ ๊ฒ์ดํธ์ด๋ฉฐ, ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ฃจํธ ๋ ธ๋๊ฐ ๊ณง ๋์ ๊ฒ์ดํธ๊ฐ ๋๋ค.
๋์ ๊ฒ์ดํธ๊น์ง ํ๋๋ ์กด์ฌํ์ง ์์, ๋ฃจํธ ๋
ธ๋๊ฐ 0
์ด ๋๋ค๋ฉด ์ด๋ ๊ณตํญ์ด ํ์๋จ์ ์๋ฏธํ์ฌ ์ข
๋ฃํด์ค๋ค.
2
์ plane
์๊ฒ๋ 1,2
์ด๋ผ๋ ๊ฒ์ดํธ์ ๋ํนํ ์ ์๋ ์ ํ์ง๊ฐ ์ฃผ์ด์ง๋ค.
์ฌ๊ธฐ์ ์ฐ์ ์ ์ผ๋ก ๋ณธ์ธ๊ณผ ๋์ผํ ์ซ์์ ๊ฒ์ดํธ๋ฅผ ์ ํํ๋ค. ์๋ค๋ฉด ์ต๋ํ ๊ฐ๊น์ด ์ซ์์ ๊ฒ์ดํธ๋ฅผ ์ ํํ๋ค.
๋ง์ฝ ๋ค์๋ฒ์ 2
์ด๋ผ๋ plane
์ด ๋์ผํ๊ฒ ๋์จ๋ค๋ฉด, 2
๋ฒ ๊ฒ์ดํธ๋ ์ด๋ฏธ ์ฌ์ฉ์ค์ด๊ธฐ์ ๊ทธ ์ด์ ์ซ์์ธ 1
๋ฒ ๊ฒ์ดํธ๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ค.
์ด๊ธฐ
root
์ํ๋ ๋ค์๊ณผ ๊ฐ๋ค. ์ด๋ ๊ณง ๋ชจ๋ ๊ฒ์ดํธ๋ฅผ ์ฌ์ฉํ ์ ์์์ ์๋ฏธํ๋ค.
root
: [0,1,2,3,4]
์ด์ ์ฒซ๋ฒ์งธ๋ก,
plane
์ ์์์ธ2
๋ฅผ ์ธ์๋กfind
ํจ์๋ฅผ ์คํ์ํจ๋ค.
ํ์ฌ root[2]
๋ํ 2
์ด๊ธฐ ๋๋ฌธ์, gate
์๋ 2
๊ฐ ๊ทธ๋๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค.
์ฌ๊ธฐ์ ๋ณธ์ธ๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ์ซ์์ธ 2
๋ฒ ๊ฒ์ดํธ๋ฅผ ์ ํํด์ฃผ๊ณ , root[2]
์ ์์๋ฅผ -1
ํด์ค๋ค.
ํ root
์ํ: [0,1,1,3,4]
๋๋ฒ์งธ๋ก, ๋์ผํ๊ฒ
2
๋ผ๋ ์์๋ฅผ ์ธ์๋กfind
ํจ์๋ฅผ ์คํ์ํจ๋ค.
์ด์ ๊ณผ์ ์ ํตํด์ root[2]
์๋ 2
๊ฐ ์๋ 1
์ด ๋ค์ด์๊ธฐ ๋๋ฌธ์, ์ต์ข
์ ์ผ๋ก 1
์ ๋ฆฌํดํ๋ค.
1
๋ฒ ๊ฒ์ดํธ๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก, ๋นํ๊ธฐ๋ฅผ ๋ํนํ๊ณ root[1]
์ -1
ํด์ค๋ค.
ํ root
์ํ: [0,0,1,3,4]
์ธ๋ฒ์งธ๋ก,
3
์ด๋ผ๋ ์์๋ฅผ ์ธ์๋กfind
ํจ์๋ฅผ ์คํ์ํจ๋ค.
ํ์ฌ root[3]
๋ํ 3
์ด๊ธฐ ๋๋ฌธ์, gate
์๋ 3
์ด ๊ทธ๋๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค.
3
๋ฒ ๊ฒ์ดํธ๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก, ๋นํ๊ธฐ๋ฅผ ๋ํนํ๊ณ root[1]
์ -1
ํด์ค๋ค.
ํ root
์ํ: [0,0,1,2,4]
๋ค๋ฒ์งธ๋ก, ๋์ผํ๊ฒ
3
์ด๋ผ๋ ์์๋ฅผ ์ธ์๋กfind
ํจ์๋ฅผ ์คํ์ํจ๋ค.
์ด์ ๊ณผ์ ์ ํตํด์ root[3]
์๋ 3
์ด ์๋ 2
๊ฐ ๋ค์ด์๋ค.
๋ค์์ผ๋ก root[2]
์๋ 1
์ด ๋ค์ด์์ผ๋ฉฐ, root[1]
์๋ 0
์ด ๋ค์ด์์ด ์ต์ข
์ ์ผ๋ก 0
์ ๋ฆฌํดํ๋ค.
gate == 0
์ด๊ธฐ ๋๋ฌธ์, ๋ ์ด์ ์ด์ฉ๊ฐ๋ฅํ ๊ฒ์ดํธ๊ฐ ์๋ ๊ฒ์ผ๋ก ํ๋จํ๊ณ ํ์ํ๋ค.
์ด 3
๊ฐ์ ๋นํ๊ธฐ๊ฐ ๋ํน์ ์ฑ๊ณตํ์์ผ๋ฏ๋ก ์ด๋ฅผ ์ถ๋ ฅํด์ค๋ค.
๋๋ ์ & ๋ฐฐ์ด ์
์ค๋๋ง์ ์ ๋์จ ํ์ธ๋๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ์ฌ์ ์กฐ๊ธ ๋นํฉํ๋ค. ์ด๋ฐ ์์ผ๋ก ๊ทธ๋ฆฌ๋์ ์ ๋์จ ํ์ธ๋๋ฅผ ๊ฒฐํฉํ ์ ์์์ ์๊ฒ ๋ ๋ฌธ์ ์๋ค.
๋ฃจํธ ๋ ธ๋๋ฅผ ๊ฒ์ดํธ ๋ฒํธ๋ก ๋๊ณ , ์ฌ์ฉํ๋ฉด ํ๋์ฉ ์ค์ด๋ฉฐ ๋์ ๊ฒ์ดํธ๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ค๋ ์ ์ ๋ ์ฌ๋ฆฌ๊ธฐ๋ ์ฝ์ง ์์๋ค..