[BOJ][๐ก4][๋ฐฑ์ค#01976] ์ฌํ ๊ฐ์
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
๋ํ์ด๋ ์น๊ตฌ๋ค๊ณผ ํจ๊ป ์ฌํ์ ๊ฐ๋ ค๊ณ ํ๋ค. ํ๊ตญ์๋ ๋์๊ฐ N๊ฐ ์๊ณ ์์์ ๋ ๋์ ์ฌ์ด์ ๊ธธ์ด ์์ ์๋, ์์ ์๋ ์๋ค. ๋ํ์ด์ ์ฌํ ์ผ์ ์ด ์ฃผ์ด์ก์ ๋, ์ด ์ฌํ ๊ฒฝ๋ก๊ฐ ๊ฐ๋ฅํ ๊ฒ์ธ์ง ์์๋ณด์. ๋ฌผ๋ก ์ค๊ฐ์ ๋ค๋ฅธ ๋์๋ฅผ ๊ฒฝ์ ํด์ ์ฌํ์ ํ ์๋ ์๋ค. ์๋ฅผ ๋ค์ด ๋์๊ฐ 5๊ฐ ์๊ณ , A-B, B-C, A-D, B-D, E-A์ ๊ธธ์ด ์๊ณ , ๋ํ์ด์ ์ฌํ ๊ณํ์ด E C B C D ๋ผ๋ฉด E-A-B-C-B-C-B-D๋ผ๋ ์ฌํ๊ฒฝ๋ก๋ฅผ ํตํด ๋ชฉ์ ์ ๋ฌ์ฑํ ์ ์๋ค. ๋์๋ค์ ๊ฐ์์ ๋์๋ค ๊ฐ์ ์ฐ๊ฒฐ ์ฌ๋ถ๊ฐ ์ฃผ์ด์ ธ ์๊ณ , ๋ํ์ด์ ์ฌํ ๊ณํ์ ์ํ ๋์๋ค์ด ์์๋๋ก ์ฃผ์ด์ก์ ๋ ๊ฐ๋ฅํ์ง ์ฌ๋ถ๋ฅผ ํ๋ณํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๊ฐ์ ๋์๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ฐฉ๋ฌธํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
์ ๋ ฅ
์ฒซ ์ค์ ๋์์ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 200์ดํ์ด๋ค. ๋์งธ ์ค์ ์ฌํ ๊ณํ์ ์ํ ๋์๋ค์ ์ M์ด ์ฃผ์ด์ง๋ค. M์ 1000์ดํ์ด๋ค. ๋ค์ N๊ฐ์ ์ค์๋ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. i๋ฒ์งธ ์ค์ j๋ฒ์งธ ์๋ i๋ฒ ๋์์ j๋ฒ ๋์์ ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ์๋ฏธํ๋ค.ย 1์ด๋ฉด ์ฐ๊ฒฐ๋ ๊ฒ์ด๊ณ 0์ด๋ฉด ์ฐ๊ฒฐ์ด ๋์ง ์์ ๊ฒ์ด๋ค. A์ B๊ฐ ์ฐ๊ฒฐ๋์์ผ๋ฉด B์ A๋ ์ฐ๊ฒฐ๋์ด ์๋ค. ๋ง์ง๋ง ์ค์๋ ์ฌํ ๊ณํ์ด ์ฃผ์ด์ง๋ค. ๋์์ ๋ฒํธ๋ 1๋ถํฐ N๊น์ง ์ฐจ๋ก๋๋ก ๋งค๊ฒจ์ ธ ์๋ค.
์ถ๋ ฅ
์ฒซ ์ค์ ๊ฐ๋ฅํ๋ฉด YES ๋ถ๊ฐ๋ฅํ๋ฉด NO๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
3
3
0 1 0
1 0 1
0 1 0
1 2 3
์ถ๋ ฅ
YES
My Sol
def find(x):
if x == p[x]:
return x
p[x] = find(p[x])
return p[x]
def check():
global root
for n in path:
if not find(n) == root: return 'NO'
return 'YES'
N = int(input())
M = int(input())
mat = [list(map(int, input().split())) for _ in range(N)]
path = list(map(lambda x: int(x)-1, input().split()))
p = list(range(N))
for u in range(1, N):
for v in range(u):
if not mat[u][v]: continue
a = find(u)
b = find(v)
if a == b: continue
p[a] = b
root = find(path[0])
print(check())
union-find ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ ๋ฃจํธ ๋ ธ๋๊ฐ ๋ฌด์์ธ์ง ์ฐพ๋ ๋ฐฉ๋ฒ์ผ๋ก, ์ฌํ ๊ฒฝ๋ก์ ํด๋นํ๋ ๋ชจ๋ ๋ ธ๋๋ค์ด ํ ๋ฃจํธ ๋ ธ๋๋ฅผ ๊ณต์ ํ๋ค๋ฉด ๋ชจ๋ ์ฐ๊ฒฐ๋์ด์๋ค๊ณ ๋ณธ๋ค. ๋ง์ฝ ๊ทธ๋ ์ง ์๋ค๋ฉด NO๋ฅผ ์ถ๋ ฅํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ถ๋ชจ ํ๊ทธ๋ฅผ union ํด์ฃผ๋ ๊ฒ find(x), find(y)ํ ๊ฒ ์์ฒด๋ฅผ p๋ก ๋ฌถ์ด์ฃผ๋ ๊ฑด๋ฐ ์ด ๋ถ๋ถ์ด ํท๊ฐ๋ ค์ ์๊พธ ํ๋ฆฐ๋ค. ์ด๊ฑธ ์์ฃผ ์ค์ํ๋ ๊ฒ ๊ฐ๋ค.
๋ชจ๋ฒ๋ต์
# empty
๋๊ธ๋จ๊ธฐ๊ธฐ