10-alstjr7437

[alstjr7437]

🔗 문제 링크

트리의 부모 찾기

✔️ 소요된 시간

30분

✨ 수도 코드

트리부분을 많이 까먹어서 새롭게 시작하는 느낌으로 트리의 기본 같은 각 노드의 부모를 return 해주는 문제입니다!!

저는 일단 트리를 오래만에 만들어서 딕셔너리를 사용했습니다!!
따로 문제를 읽어보니 노드의 개수가 정해져서 n이 6이면 1~6까지의 노드만 있으면 되겠더라구요
그리고 루트 노드도 1로 고정이 되어있더라구요
그래서 1 : [] 2: [] 3: [] 이런식으로 딕셔너리를 미리 생성시켜줬습니다.

그리고 BFS와 DFS를 이용한 탐색으로 각 노드의 부모를 들고와 배열에 저장했습니다!

예제는 아래와 같습니다!

BFS(너비 우선 탐색)

너비 우선 탐색의 방법으로 일단 큐(queue) 배열을 만들고

1. queue 배열에 루트를 넣는다.
2. queue가 없어질때까지 반복
   1. queue에 제일 왼쪽 부분을 빼준다 - 1
   2. 제일 왼쪽과 연결된 부분의 수를 넣는다. - 6, 4
   3. visited(부모 넣어두는 배열)에 뺀 왼쪽 부분을 넣어준다. - 1을 추가
3. visited 배열 출력

위와 같이 진행하게 되면
1 - [6,4] - [4,3] - [3,2] - [3,2,7] - [2,7,5] - [7,5] - [5] - 종료
식으로 진행되게 됩니다!

아래 표는 visited가 바뀌는 순서입니다!!

0	1	2	3	4	5	6	7
0	'Root'	0	0	1	0	1	0
0	'Root'	0	6	1	0	1	0
0	'Root'	0	0	0	0	1	0
0	'Root'	4	6	1	0	1	0
0	'Root'	4	6	1	0	1	4
0	'Root'	4	6	1	3	1	4

DFS(깊이 우선 탐색)

visited에 0이 아니면 계속해서 dfs 재귀 함수를 돌도록 하였습니다!

1. visited에 1에 다른걸 넣고 1부터 돌린다.(안넣으니 1의 루트도 생성해버리더라구요..)
2. 재귀함수 실행
   1. 재귀함수에서 온 a와 연결된 수가 반복문을 통해 돌아간다. - 6
   2. 반복문 중 재귀함수가 들어가서 다른 노드도 살펴본다 - 3
   3. 다 들어갔다 나왔으면 다시 1로 돌아와서 다른 부분을 호출한다. - 4
3. visited 배열 출력

위와 같이 진행하게 되면 1 -> 6 -> 3 -> 5 -> 2 -> 7 -> 종료로 진행하게 됩니다!

0	1	2	3	4	5	6	7
0	'Root'	0	0	0	0	1	0
0	'Root'	0	6	0	0	1	0
0	'Root'	0	6	0	3	1	0
0	'Root'	0	6	1	3	1	0
0	'Root'	4	6	1	3	1	0
0	'Root'	4	6	1	3	1	4

코드

import sys
sys.setrecursionlimit(10**8) #재귀 리미트
from collections import deque

n = int(input())

# 트리 만들기
tree = {i:[] for i in range(1,n+1)}
for i in range(n-1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)
# print(tree)

# 부모 저장하기
visited = [0] * (n+1)

# DFS
def dfs(a):
    for i in tree[a]:
        if visited[i] == 0:
            visited[i] = a
            # print(visited, i, a)
            dfs(i)

# BFS
def bfs():
    while queue:
        a = queue.popleft()
        for i in tree[a]:
            if visited[i] == 0:
                queue.append(i)
                visited[i] = a
                # print(visited, queue)


visited[1] = 'Root'

# dfs(1)

queue = deque()
queue.append(1)
bfs()

for i in range(2, n+1):
    print(visited[i])

📚 새롭게 알게된 내용

오래만에 다시 트리에 대해 생각하고 트리를 구현하고 만들어봤고
BFS, DFS를 통한 탐색하여서 부모의 수를 넣어주는 부분까지 간단하게 하여서 다시 트리에 대해 공부하게 됐습니다!!!

[9kyo-hwang]

뭔가 킹받네요 이거

[alstjr7437]

뭔가 킹받네요 이거

이걸 보다니.. 아래와 같이 어머니가 자꾸 아들을 어머니로 인식해서 넣어 버리더라구요...

그래서 짜증나서 값을 바꿔주다가..

[9kyo-hwang]

보통 DFS는 recursion을 통해 많이 구현하지만, 이 문제는 stack으로 간단하게 구현하신 분들이 많네요? 요게 속도도 빠르구요.

input = open(0).readline

N = int(input())
tree = [[] for _ in range(N + 1)]

for _ in range(N - 1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)
    
parents = [0] * (N + 1)

stack = [1]
while stack:
    src = stack.pop()
    for dst in tree[src]:
        if not parents[dst]:
            parents[dst] = src
            stack.append(dst)

print(*parents[2:], sep='\n')

[alstjr7437]

보통 DFS는 recursion을 통해 많이 구현하지만, 이 문제는 stack으로 간단하게 구현하신 분들이 많네요? 요게 속도도 빠르구요.

혹시 이 코드는 stack으로 BFS를 이용해 한 부분 아닌가요!!?

[9kyo-hwang]

보통 DFS는 recursion을 통해 많이 구현하지만, 이 문제는 stack으로 간단하게 구현하신 분들이 많네요? 요게 속도도 빠르구요.

혹시 이 코드는 stack으로 BFS를 이용해 한 부분 아닌가요!!?

DFS입니다. 감사합니다.

[fnzksxl]

저도 똑같이 루트 노드가 다르게 되는 이슈가 발생했던.. 카톡에서 바꿔적은 코드 그대로 입니다 ㅋㅋㅋ 감 잡기엔 딱 좋은 문제같아요

from heapq import heappop, heappush

n = int(input())

tree = {i: [] for i in range(1, n + 1)}

for i in range(n - 1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)

visited = [0] * (n + 1)

q = []
heappush(q,1)

while q:
  node = heappop(q)
  for next_node in tree[node]:
    if not visited[next_node]:
      visited[next_node] = node
      heappush(q, next_node)

print(*visited[2:])

[SeongHoonC]

저는 bfs 로 풀었습니다!

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val n = br.readLine().toInt()
    val graph = List<MutableList<Int>>(n + 1) { mutableListOf() }
    val parents = Array(n + 1) { 0 }

    for (i in 0 until n - 1) {
        val (nodeA, nodeB) = br.readLine().split(" ").map { it.toInt() }
        graph[nodeA].add(nodeB)
        graph[nodeB].add(nodeA)
    }

    val q = ArrayDeque<Int>()
    q.add(1)

    while (q.isNotEmpty()) {
        val parent = q.removeFirst()
        for (node in graph[parent]) {
            if (parents[node] != 0) {
                continue
            }
            parents[node] = parent
            q.add(node)
        }
    }

    for (i in 2..n) {
        println(parents[i])
    }
}

[SeongHoonC]

타입이 없다니..이게 인터프리터 언어?

[SeongHoonC]

Suggested change

	if visited[i] == 0:
	queue.append(i)
	visited[i] = a
	if visited[i] != 0:
	continue
	queue.append(i)
	visited[i] = a

이렇게 하면 depth 를 줄일 수 있습니다.
조건문이 많아지면 장풍은 혼란을 야기합죠

[wkdghdwns199]

쉽게 생각했었는데.. 혼자 풀어볼려다가 왜 안되는 거지 하면서 민석님 코드 이래저래 살펴보면서 이해했습니다 ㅜㅜ 그리고 dfs 로 푸니까 겁나 느리네요 ..!

import sys
sys.setrecursionlimit(10**9)
N = int(input())
tree = {i:[] for i in range(1, N+1)}


for _ in range(N-1) :
    a,b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)

answer = [0 for _ in range(N+1)]

def dfs(current_node) :
    for node in tree[current_node] :
        if answer[node] == 0 :
            answer[node] = current_node
            dfs(node)

answer[1] = 1
dfs(1)

for index in range(2,N+1) :
    print(answer[index])