59-tgyuuAn

[tgyuuAn]

🔗 문제 링크

개미

✔️ 소요된 시간

2시간

진짜... 문제 분류 안보고... 레퍼런스도 안보고...

서울 -> 부산가는 itx에서 5시간동안 할 것도 없고 해서... 핫스팟 키고 노트북 펼쳐서 풀었는데

디스코드에서 고군분투 하면서 원큐에 풀었어요... 🫡🫡🫡

진짜... 완전 짜릿해..

✨ 수도 코드

근데 문제 풀고나서 알고리즘 분류를 보니까 희소 배열이라고 하네요.

일단 저는 그렇게 안 풀었구 다익스트라 + 이분 탐색 으로 풀었씁니다!

일단 문제를 자세히 보면,

개미는 집짓기의 달인이기 때문에 불필요한 굴은 짓지 않는다.

그래서 굴을 타고 한 방에서 다른 방으로 갈 수 있는 경로는 항상 존재하며 유일하다.

임의의 두 방 사이의 거리는 두 개의 방을 연결하는 경로를 구성하는 굴의 길이의 합이다.

방의 개수는 n이고, 간선의 개수는 n-1이다.

라는 지문에서 개미굴은 아래와 같은 형태로 만들어져있음을 알 수 있습니다.

또한,

자연수 n이 주어진다. n은 방의 개수이다. (1 ≤ n ≤ 10^5)

에서 $O(n^2)$ 의 시간복잡도인 알고리즘을 사용하면 1억이 훌쩍 넘어버리니,

최대 $O(n * log(n))$ 의 시간복잡도로 풀어야 함을 알 수 있습니다.

처음에는, AlgoLeadMe/AlgoLeadMe-6#2 문제 처럼,

1번 개미굴에서 다익스트라 한 번 돌리면 $O(n * log(n))$ 으로 풀 수 있어서 개꿀 아냐 ...? 했는데,

오산이었씁니다.

이제 뭐 모든 개미가 체력이 무한이어서 모두 1번 방까지 갈 수 있으면 OK 였겠지만,

개미의 체력이 한정적이라 1번 까지 도달하지 못할 수 있고,

이럴 경우 1번과 가장 가까운 방의 번호를 제출해야만 해요.

그럼 또 위 그림 기준에서 3번 노드를 기준으로 다익스트라를 돌려야만 할까요 ?

그러면 모든 노드에서 다익스트라를 돌리는 꼴이니까 $O(n * n log(n))$ 이 되니까 시간이 터집니다!

자자, 이걸 어떻게 해결하느냐,

저는 이렇게 접근했습니다.

위에서 어차피 개미굴은 불필요한 방을 만든다고 하지 않았으므로,

각 노드는 1번 방 까지 가는 경로가 단 하나밖에 존재하지 않습니다.

오케이 오케이.

1번 노드부터 다익스트라를 돌리는거 까지는 동일해요.

그리고 추가적으로 다익스트라를 돌릴 때, 부모 노드의 정보까지 저해줍니다

이 과정은 그냥 힙에 넣을 때 이전 노드를 다음 노드의 부모로 설정해주면 되어요.

heap = [(0,1)]
parent = [0 for idx in range(N+1)]

while heap:
    now_cost, now_node = heappop(heap)

    if now_cost >= cost[now_node] and now_node != 1: continue
    cost[now_node] = now_cost
            
    for next_node, next_cost in graph_info[now_node].items():
        if now_cost + next_cost < cost[next_node]:
            heappush(heap, (now_cost + next_cost, next_node))
            parent[next_node] = now_node              # 바로 이 부분 입니두아!

자 이제 다 왔씁니다.

그럼 leaf 노드 (말단 노드) 만 구하면 부모 노드 정보를 이용해서 해당 경로에 대한 정보를 모두 얻을 수 있어요.

위 그림과 같이

[(8, 15), (5, 10), (2, 5), (1,0)] 과 같이 해당 경로의 노드 정보와 소모하는 체력을 알 수 있습니다.

위 코드는 아래와 같습니둥.

for leaf in leaf_node:
    now_node = leaf
    now_road = deque()

    while now_node != 0:
        now_road.append((now_node, cost[now_node]))
        now_node = parent[now_node]

그럼 위 코드를 실행하려면 leaf 노드가 무엇인지를 알아야겠죠 ?

leaf 노드는 잘 보면 해당 노드와 이어져 있는 노드가 1개 밖에 없는 노드들입니다.

이 때 1번 노드가 2번 노드랑만 연결되어있는 경우도 있으니 1번 노드는 제외 해줍니둥.

leaf_node = deque()
for node, value in enumerate(neighbor_count):
    if node in (0, 1): continue
    if value == 1: leaf_node.append(node)

위 까지의 과정은 모두 시간 복잡도 $O(n * log(n)$ 으로 했습니다.

자 이제 그럼 아래 그림처럼 각 leaf 노드 별로 경로가 모두 완성되었습니닷

아래 그림에서는 leaf 노드가 4개라 4개의 경로가 생성되었어요.

이제 진짜 다 왔어요.

아까 저장한 각 leaf 노드 별 경로에서 [(8, 15), (5, 10), (2, 5), (1,0)]

앞에 항 부터 pop 하면서 현재 방에 있는 개미의 체력으로 어디까지 갈 있는 지 이분 탐색으로 찾아줍니다.

예를 들면 8번 방에 있는 개미의 체력이 10만큼 있다고 했을 때,

2번 방까지 갈 수 있겠죠? (8번방 까지의 거리가 15이고 2번방 까지의 거리가 5이니까 15- 5는 10 입니다.)

위와 같은 과정을 이분 탐색으로 찾아주는 것 입니둥.

def check(mid, now_road, energy):
    if now_road[0][1] - now_road[mid][1] <= energy: return True  # 만약 현재 개미의 체력으로 해당 굴 까지 갈 수 있으면 True
    return False

while now_road:
        now_idx, now_distance = now_road[0]
        now_energy = ant[now_idx-1]

        if answer[now_idx] != 0:
            now_road.popleft()
            continue
        
       # print(now_road)
        
        left = -1
        right = len(now_road)
        temp = 0
        while left+1<right:
            mid = (left+right)//2
            #print(left, mid, right)

            if check(mid, now_road, now_energy):
                temp = mid
                left = mid

            else: right = mid

        answer[now_idx] = now_road[temp][0]
        #print(answer[1:])
        #print()
        now_road.popleft()

이러면 각 노드 별로 $O(log(n))$ 의 시간 복잡도로 풀 수 있으니까,

모든 노드들 N개 * log(N) 하면 $O(n*log(n)$으로 모든 노드에 대해서 어디까지 뻗을 수 있는지 다 구할 수 있습니다!!

📚 새롭게 알게된 내용

[H0ngJu]

이번 리뷰는 리뷰가 아니라 감상평에 더 가까울 것 같네요 😯👏👏

PR을 읽는데 알고리즘 짬밥이 흘러나오는군요 .... ㄷㄷ
항상 자극 받고 갑니다 🫠

알고리즘 분류가 희소 배열이라길래 한번 찾아보았습니다
희소 배열을 이용한 풀이

희소배열을 한줄로 설명하면
'2^n 번 올라갔을 때의 노드 찾기' 즉, 어떤 노드의 2^n번째 부모찾기인 것 같아요.

최소공통조상 & 희소 배열
2^n번째 부모에 대한 정보를 dp 에 저장해두고 쓰는 것 같네요!

[H0ngJu]

딕셔너리 자료구조를 많이 안써서 생소한데

items()가 딕셔너리 key, value를 반환해주는 함수네요 줍줍

따로 정의한줄 알고 찾고 있었습니다.. ㅎㅎ

[tgyuuAn]

🫡🫡🫡👍🏻👍🏻👍🏻👍🏻

[tgyuuAn]

이번 리뷰는 리뷰가 아니라 감상평에 더 가까울 것 같네요 😯👏👏

PR을 읽는데 알고리즘 짬밥이 흘러나오는군요 .... ㄷㄷ 항상 자극 받고 갑니다 🫠

알고리즘 분류가 희소 배열이라길래 한번 찾아보았습니다 희소 배열을 이용한 풀이

희소배열을 한줄로 설명하면 '2^n 번 올라갔을 때의 노드 찾기' 즉, 어떤 노드의 2^n번째 부모찾기인 것 같아요.

최소공통조상 & 희소 배열 2^n번째 부모에 대한 정보를 dp 에 저장해두고 쓰는 것 같네요!

희소 배열 짱신기하네,,,,,,,,,,,,,,,,,,,,요.........

[9kyo-hwang]

희소 배열 쓰는 방법으로 해볼려다가, 도저히 머리에 안들어와서 PR 보고 똑같이 다익스트라 + 이진 탐색으로 츄라이...

from heapq import *
from collections import deque


def binary_search(paths: deque, energy: int) -> int:
    lo, hi = -1, len(paths)
    while lo + 1 < hi:
        mid = (lo + hi) // 2
        if paths[0][1] - paths[mid][1] <= energy:
            lo = mid
        else:
            hi = mid
            
    return 0 if lo == -1 else lo
    

def dijkstra(heap: list, distances: list, parents: list, tree: list):
    heappush(heap, (0, 1))
    distances[1] = 0
    
    while heap:
        du, u = heappop(heap)
        
        if distances[u] < du:
            continue
        
        for v, dv in tree[u]:
            if du + dv < distances[v]:
                distances[v] = du + dv
                parents[v] = u
                heappush(heap, (distances[v], v))


def main():
    input = open(0).readline
    
    n = int(input())
    energy_of_ants = [0] + [int(input()) for _ in range(n)]
    tree = [[] for _ in range(n + 1)]
    for _ in range(n - 1):
        a, b, c = map(int, input().split())
        tree[a].append((b, c))
        tree[b].append((a, c))
                
    
    heap = []
    distances = [10**9] * (n + 1)
    parents = [0] * (n + 1)
    
    dijkstra(heap, distances, parents, tree)

    answer = [0] * (n + 1)
    for i in range(2, n + 1):
        if len(tree[i]) > 1:
            continue
        
        node = i
        paths = deque()
        while node != 0:
            paths.append((node, distances[node]))
            node = parents[node]
        
        while paths:
            u, du = paths[0]
            if answer[u] != 0:
                paths.popleft()
                continue
            
            answer[u] = paths[binary_search(paths, energy_of_ants[u])][0]
            paths.popleft()
    
    print('\n'.join(map(str, answer[1:])))


if __name__ == "__main__":
    main()

[9kyo-hwang]

neighbour 수를 굳이 기록할 필요 없이, graph_info의 크기가 곧 이웃 노드 수를 의미합니다.

제 경우엔 list를 써서 그래프(트리) 정보를 기록합니다.

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

이런 식으로 하면, 밑에서 리프 노드를 판별할 때

for i in range(2, n + 1):
    if len(tree[i]) > 1:
        continue
    ...

이런 식으로 i번째 노드의 인접 리스트 길이가 1인 경우에만 확인하는 식으로 검사할 수 있습니다.

[9kyo-hwang]

위에서 언급했듯이 리프 노드를 판별하면, 이 과정은 필요없어집니다. 아래와 같이 바로 검사하면 됩니다 :)

answer = [0] * (n + 1)
for i in range(2, n + 1):
    if len(tree[i]) > 1:
        continue
    
    node = i
    paths = deque()
    while node != 0:
        paths.append((node, distances[node]))
        node = parents[node]
    
    while paths:
        ...