34-alstjr7437

[alstjr7437]

🔗 문제 링크

파티

✔️ 소요된 시간

30분

오래만에 다익스트라 연습겸 기억 복귀를 위해서 풀어봤습니다!!

그런데 다풀고 살펴보니까 태규님의 문제에 있더군요 ㄷㄷㄷ...

문제점

따로 처음에는 문제가 이해가 가지 않았습니다

마지막 글만 읽고 돌아서 가더라도 최대로 가는 방법을 구하자!!

인줄 알았는데 결과값을 보니 10이 나오더라구요!!

자세히 읽어보니최단 거리로 가지만 그 중에 제일 먼 애를 출력이더라구요

저는 그냥 어떻게 돌아서 가도 2번에 가는 최대 거리를 구하는 줄 알았네요 ㅠ

✨ 수도 코드

1. 그래프 만들기
2. 반복문 돌기
   • 파티 장소까지 가는 거리
   • 파티 장소에서 돌아오는 거리
   • 두개 더해서 거리 알기
3. 위 내용을 다익스트라로 구하기
   • 거리를 담아두기
   • 가는 곳의 거리가 현재 가려는 거리보다 가까운지 확인(예를 들어 1 -> 4, 1 -> 3 -> 4 이렇게 되면 1,3,4가 가까운게 확인됨)
   • 가까우면 해당 부분으로 거리를 최신화하고 큐에 넣기
   • 가깝지 않으면 큐에 넣지 않고 끝

으로 구현을 했습니다!

코드

from collections import deque 
import sys

input = sys.stdin.readline
INF = int(1e9)

N, M, X = map(int, input().split())

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

for _ in range(M):
    start, target, dist = map(int, input().split())
    graph[start].append((target, dist))

def dijkstra(root):
    queue = deque()
    distance = [INF] * (N + 1)

    distance[root] = 0
    queue.append((root, 0))
    while queue:
        now, dist = queue.popleft()
        
        for target, cost in graph[now]:
            target_cost = dist + cost

            if distance[target] > target_cost:
                distance[target] = target_cost
                queue.append((target, target_cost))
    return distance

result = []
for i in range(1, N+1):
    go = dijkstra(i)[X]
    back = dijkstra(X)[i]
    result.append(go+back)

print(max(result))

📚 새롭게 알게된 내용

[tgyuuAn]

from heapq import *
from collections import defaultdict

total_node_count, total_edge_count, target_node = map(int,input().split(" "))

visited = [False for _ in range(total_node_count+1)]
go_distance_table = [int(1e9) for _ in range(total_node_count+1)]
link_table = defaultdict(lambda: defaultdict(lambda : int(1e9)))


for _ in range(total_edge_count):
    node1, node2, weight = map(int, input().split(" "))
    link_table[node1][node2] = weight

#집에서 X로 가는 길
for idx in range(1,total_node_count+1):
    if idx == target_node:
        go_distance_table[target_node] = 0
        continue

    heap = [[0,idx]]
    temp_visited = [False for _ in range(total_node_count+1)]
    temp_distance_table = [int(1e9) for _ in range(total_node_count+1)]
    temp_distance_table[idx] = 0
    
    while heap:
        now_distance, now_node = heappop(heap)
        temp_visited[now_node] = True

        for link_node in link_table[now_node]:
            if temp_visited[link_node] == True:
                continue

            if temp_distance_table[link_node] > now_distance + link_table[now_node][link_node] :
                temp_distance_table[link_node] = now_distance + link_table[now_node][link_node]

                heappush(heap,[temp_distance_table[link_node],link_node])
    
    go_distance_table[idx] = temp_distance_table[target_node]

#X에서 집으로 돌아가는 길
come_distance_table = [int(1e9) for _ in range(total_node_count+1)]
heap = [[0,target_node]]

while heap:
    now_distance, now_node = heappop(heap)
    visited[now_node] = True

    for link_node in link_table[now_node]:
        if visited[link_node] == True:
            continue

        if come_distance_table[link_node] > now_distance + link_table[now_node][link_node] :
            come_distance_table[link_node] = now_distance +link_table[now_node][link_node]

            heappush(heap,[come_distance_table[link_node],link_node])

go_distance_table[target_node] = -1
come_distance_table[target_node] = -1
print(max([x+y for x,y in zip(go_distance_table[1:], come_distance_table[1:])]))

허허. 이렇게 맛있는 문제를 내주셔서 감사합니다 ,,,, ㅎㅎ

[H0ngJu]

다익스트라 n->x, x->n 을 두 번 돌리니까 바로 답 나오네용

다익스트라 복습 잘 했습니다옹 ~! ~! ~🫡

import sys
import heapq

INF = 1e8

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

N, M, X = map(int, input().split())
T = [[] for _ in range(N+1)]
distance = [INF] * (N+1)
cmp = [0] * (N+1)

for _ in range(M):
    u, v, w = map(int, input().split())
    T[u].append((v, w))

def dijkstra(start):
  q = []
  heapq.heappush(q, (0, start))
  distance[start] = 0

  while q:
    dist, now = heapq.heappop(q)

    if distance[now] < dist:
      continue

    for i in T[now]:
      if dist+i[1] < distance[i[0]]:
        distance[i[0]] = dist+i[1]
        heapq.heappush(q, (distance[i[0]], i[0]))

for i in range(N):
  dijkstra(i+1)
  cmp[i+1] = distance[X]
  distance = [INF] * (N+1)

dijkstra(X)
for i in range(N):
  cmp[i+1] += distance[i+1]

print(max(cmp))