27-H0ngJu

[H0ngJu]

🔗 문제 링크

트리의 지름

✔️ 소요된 시간

2H

✨ 수도 코드

문제 요약

요렇게 되는 경우의 최대 지름 구하기@!

일단 저는 이 문제를 보고

1. 최대 지름을 구하는 것이니, 끝 노드가 무조건 포함이다.
2. a, b 두 노드를 선택하고 같은 부모에서 만날 때까지 반복문 돌리면 되지 않을까?

하고 접근했습니다.

근데 또 보다보면 한가지 특징이 있는 것이,

두 노드를 잡았을 때, 결정되는 트리의 지름은
반드시 두 노드의 첫 공통 부모라는 점입니다.

위 사진에서, 9번 노드와 12번 노드를 잡았을 때,
공통 조상은 3번 노드와 1번 노드지만,

첫 번째로 등장하는 조상 노드는 3번 노드이기 때문에,

트리의 지름이 3번 노드를 기준으로 한 각각의 거리라는 의미입니다.

그래서 저는 각 노드들에 대해서 조상을 담을 parent 리스트와, 가중치 정보를 담을 tree를 따로 두어서 저장하고,

두 노드들의 공통 조상 중에 가장 큰 것을 뽑아
트리의 최대 지름을 구하면 되겠구나! 해서

열심히 코드를 작성했고,,,

import sys

def input() : return sys.stdin.readline().rstrip()

n = int(input())
tree = [[] for _ in range(n+1)]
parents = [[] for _ in range(n+1)]
max_dis = 0

for i in range(1, n):
    v, u, w = map(int, input().split())
    
    if v == 1:
        tree[u].append(list((v, w)))
    else:
        tree[u].append(list((v, w)))
        parents[u].append(v)

        for arr in tree[v]:
            tree[u].append(list((arr[0], w + arr[1])))
            parents[u].append(arr[0])

for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == j:
            continue

        min_common_value_i = 0
        min_common_value_j = 0
        check = 0

        for parent in parents[i]:
            if check:
                break
            if parent in parents[j]:
                check = 1
                min_common_value_i = next((x[1] for x in tree[i] if x[0] == parent), None)
                min_common_value_j = next((x[1] for x in tree[j] if x[0] == parent), None)
                max_dis = max(max_dis, min_common_value_i + min_common_value_j)

            min_common_value = min_common_value_i + min_common_value_j

print(max_dis)

했는데,,
시간초과 입니다.

왜냐면,, n이 10000이하라 시간 복잡도가 O^2되는 순간 탈락입니다..

n이 얼마인지 확인하고 들어갔어야 하는 건데 ,,,,
걍 들이밀었더니 2시간이 그냥 날라갔네예

딱히 별다른 풀이가 더 이상 떠오르지 않아서 다른 레퍼런스를 참고했고,
DFS로 해결했습니다.

으으 n을 먼저 확인했어야 하는건데 ...

DFS의 아이디어는 아래를 기초로 합니다!

끝노드가 반드시 트리의 최대 지름을 결정한다.

루트 기준으로 가장 먼 노드는 끝노드일 수 밖에 없습니다. 끝노드보다 더 먼 노드가 존재하는 순간, 끝 노드가 끝 노드가 아니게 되는거니까요.

그래서 일단 루트노드에서 가장 먼 끝 노드를 dfs로 찾아줍니다.

그렇다면, 루트에서 가장 먼 끝 노드를 기준으로
dfs로 가장 먼 노드를 찾습니다.

그렇게 되면 트리의 최대 지름이 나옵니다!

import sys

sys.setrecursionlimit(10**9)
def input() : return sys.stdin.readline().rstrip()

n = int(input())
tree = [[] for _ in range(n+1)]
visited = [-1] * (n+1)
visited[1] = 0

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

def dfs(start, dis):
    for node, node_dis in tree[start]:
        if visited[node] == -1:
            visited[node] = dis + node_dis
            dfs(node, dis + node_dis)

dfs(1,0)

far_node = visited.index(max(visited))
visited = [-1] * (n+1)
visited[far_node] = 0
dfs(far_node, 0)

print(max(visited))

시간은 오래 걸렸는데
글로 옮겨 적으니까 좀 간단해보이네요 ...

그래도 어려웠습니다 🤯

📚 새롭게 알게된 내용

[tgyuuAn]

이 문제 엄청 재밌게 풀었던 기억이 있네용

저도 이 문제 도저히 몰라서 레퍼런스 보고 풀었는데, 무릎을 탁 쳤습니다...

import sys
from collections import defaultdict

sys.setrecursionlimit(100000)

def input(): return sys.stdin.readline()

N = int(input())
graph = defaultdict(list)
table = [int(1e9) for _ in range(N+1)]
table[1] = 0

def dfs(now, visited, table):
    for next, cost in graph[now]:
        if next in visited: continue
        
        visited.add(next)
        table[next] = table[now] + cost
        dfs(next, visited, table)
    

for _ in range(N-1):
    start, destination, cost = map(int,input().split())
    graph[start].append([destination, cost])
    graph[destination].append([start, cost])

visited = {1,}
dfs(1, visited, table)

max_value = -1
max_idx = 0
for idx, value in enumerate(table):
    if idx == 0: continue

    if max_value < value:
        max_value = value
        max_idx = idx

visited = {max_idx,}
table = [int(1e9) for _ in range(N+1)]
table[max_idx] = 0
dfs(max_idx, visited, table)
print(max(table[1:]))

이 문제보다 살짝 더 어려운 문제가 있는데,

두 번째 트리의 지름 문제도 한 번 풀어보실래요?!

다음 PR에 올리셔도 좋아요.