[Python] ๋ฐฑ์ค 11725 ํธ๋ฆฌ์ ๋ถ๋ชจ ์ฐพ๊ธฐ (DFS)


๐ ๋ฌธ์
๋ฃจํธ ์๋ ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋, ํธ๋ฆฌ์ ๋ฃจํธ๋ฅผ 1์ด๋ผ๊ณ ์ ํ์ ๋, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ ธ๋์ ๊ฐ์ N (2 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N-1๊ฐ์ ์ค์ ํธ๋ฆฌ ์์์ ์ฐ๊ฒฐ๋ ๋ ์ ์ ์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค๋ถํฐ N-1๊ฐ์ ์ค์ ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋ ๋ฒํธ๋ฅผ 2๋ฒ ๋ ธ๋๋ถํฐ ์์๋๋ก ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
7
1 6
6 3
3 5
4 1
2 4
4 7
์์ ์ถ๋ ฅ 1
4
6
1
3
1
4
์์ ์ ๋ ฅ 2
12
1 2
1 3
2 4
3 5
3 6
4 7
4 8
5 9
5 10
6 11
6 12
์์ ์ถ๋ ฅ 2
1
1
2
3
3
4
4
5
5
6
6
๐ ํ์ด
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def dfs(node):
visited[node] = 1
for i in graph[node]:
if not visited[i]:
parent[i] = node
dfs(i)
if __name__ == '__main__':
n = int(input())
graph = [[] for _ in range(n+1)]
visited = [0] * (n+1)
parent = [0] * (n+1)
while True:
try:
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
except:
break
for i in range(n+1):
graph[i].sort()
dfs(1)
print(*parent[2:], sep='\n')
visited[i] == 1์ด๋ฉด ๋
ธ๋ i์ ์ด๋ฏธ ๋ฐฉ๋ฌธํ๊ณ ๋ถ๋ชจ ์ฒดํฌ๋ ๋๋ธ ๊ฒ
visited[i] == 0์ด๋ฉด ๋
ธ๋ i์ ์์ง ๋ฐฉ๋ฌธํ์ง ์์์ ๋ถ๋ชจ ์ฒดํฌ๋ ํด์ผํ๋ ๊ฒ

sys.setrecursionlimit()
Python์ด ์ ํ ์ต๋ ์ฌ๊ท ๊น์ด๋ sys.getrecursionlimit()์ ์ด์ฉํด ํ์ธํ ์ ์์ต๋๋ค. BOJ์ ์ฑ์ ์๋ฒ์์ ์ด ๊ฐ์ 1,000์ผ๋ก ๋์ด ์์ต๋๋ค. ์ฌ๊ท ํธ์ถ ํ์๊ฐ ์ด ๊ฐ์ ๋์ผ๋ฉด ReferenceError๊ฐ ๋น๋๋ค.
sys.setrecursionlimit()์ ์ฌ์ฉํ๋ฉด Python์ด ์ ํ ์ต๋ ์ฌ๊ท ๊น์ด๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. ๋ฌธ์ ์ ์ ๋ ฅ๊ฐ์ ๋ณด๊ณ ์ฌ๊ท๊ฐ ์ผ๋ง๋ ์ผ์ด๋ ์ง ๊ฐ๋ ํ์ฌ ๊น์ด๋ฅผ ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋ฉ๋๋ค. ์ด ๋ฌธ์ ์์๋ n์ด ์ต๋ 100,000์ด๋ฏ๋ก ๋๋ํ sys.setrecursionlimit(10**6)์ผ๋ก ์ค์ ํ๋ ์ ๋ต ํ์ ์ ๋ฐ์ ์ ์์์ต๋๋ค.
sys.setrecursionlimit()๋ก ์ค์ ํ ์ ์๋ ์ต๋๊ฐ์ ํฌ๊ฒ ๋ณ๊ฒฝํ๋ค๊ณ ํ๋๋ผ๋, ์ฌ๊ท์ ๊น์ด๊ฐ ์ฑ์ ์๋ฒ๊ฐ ๊ฐ๋นํ ์ ์๋ ์ ๋๋ก ๊น์ด์ง๋ฉด, Segmentation fault๊ฐ ๋ฐ์ํด ๋ฐํ์ ์๋ฌ ์ด์ ๋ก SegFault๋ฅผ ๋ฐ๊ฒ ๋๋ ์ฃผ์ํด์ผ ํฉ๋๋ค.