12-fnzksxl

[fnzksxl]

🔗 문제 링크

타임머신

✔️ 소요된 시간

40분

✨ 수도 코드

음수 가중치가 있다? 그러면 먼저 벨만-포드 알고리즘이 떠올라야 합니다! (경우에 따라 다익스트라도 가능은 합니다)
심지어, 음수 사이클도 찾아야 하는 문제.. 벨만-포드로 풀어야만 하는 문제 같군요.

왠지 분기점 잘 잡으면 다익스트라로 될 것 같죠? 대놓고 벨만-포드로 풀라고 하길래
저는 괜시리 심술이 나서 다익스트라로 코드도 짜봤습니다.

from heapq import *
import sys

input = sys.stdin.readline


def func():
    heappush(q, (1, 0))
    distances[1] = 0

    while q:
        cur_dest, cur_weight = heappop(q)
        if distances[cur_dest] < cur_weight:
            continue

        for next_dest, next_weight in graph[cur_dest]:
            distance = cur_weight + next_weight
            if next_dest == 1 and distance < 0:
                return False
            if distance < distances[next_dest]:
                distances[next_dest] = distance
                heappush(q, (next_dest, distance))

    return True


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

graph = [[] for _ in range(N+1)]
distances = [float('inf')] * (N+1)
q = []

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


if func():
    for weight in distances[2:]:
        if weight == float('inf'):
            print(-1)
        else:
            print(weight)
else:
    print(-1)

근데 이 코드는 절대 안 됩니다. 명확한 반례가 있으니 한 번 생각해보세요!
언제 다익스트라를 쓰면 안 되는지 깨달을 수 있습니다.
잘 안 떠오르신다면 알려드리겠슴니다. 찡끗🎃

---

이 문제는 벨만-포드의 기본을 충실하게 따라가면 바로 풀립니다.
혹시나 기억이 잘 안 나시는 분들을 위해 간단하게 설명을 드리자면
노드의 개수만큼 모든 간선을 한 번 따라가 봅니다.
근데 그래프 내에서 최소 경로를 찾았을 때 그 경로는 총 N-1개의 간선을 사용하게 될텐데요.
N번째 반복에서도 갱신이 된다면 음수 사이클이 존재한다는 걸 알 수 있는 알고리즘입니다.

1. 음수 사이클이 존재하지 않을 때

최초 상태입니다. 흐름을 따라오시기 편하도록 계산이 되는 순서를 옆에 적어뒀습니다.

모든 간선들을 순회해서 거리를 계산해줍니다.

N번 째 라운드인 R3의 값과 R2의 값이 똑같죠? 갱신이 일어나지 않았다는 것은 음수 사이클이 없다는 뜻입니다.

2. 음수 사이클이 존재할 때

최초 상태입니다.

어? 수상한 냄새가 나는 숫자들로 거리가 바뀌었군요.

음수 사이클이 존재하지 않는다면, 여기서 새로 갱신이 없어야 하지만 갱신이 일어납니다.
갱신이 발생했다는 것은? 음수 사이클이 있다는 것이죠.

전체 코드

import sys

input = sys.stdin.readline


def func():
    distances[1] = 0

    for i in range(N):
        for j in range(M):
            cur_node, next_node, weight = edges[j]
            if distances[cur_node] != float('inf') and distances[next_node] > distances[cur_node] + weight:
                distances[next_node] = distances[cur_node] + weight
                if i == N-1:
                    return False

    return True


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

edges = []
distances = [float('inf')] * (N+1)
q = []

for _ in range(M):
    start, end, weight = map(int, input().split())
    edges.append((start, end, weight))


if func():
    for weight in distances[2:]:
        if weight == float('inf'):
            print(-1)
        else:
            print(weight)
else:
    print(-1)

📚 새롭게 알게된 내용

안 되는건 안 되는 거다.

[alstjr7437]

            if next_dest == 1 and distance < 0:
                return False

이부분에서 음수 가중치를 처리했기 떄문인가요!!?

문제를 풀어봤는데 그래프 만드는거부터 다시 공부를 해야할 것 같네요..

[SeongHoonC]

먼저 좋은 문제 공유 감사드립니다.
벨먼 포드를 처음 접해서 해당 알고리즘을 공부하고 풀었습니다.
푼 방법은 똑같네요

import java.io.BufferedReader
import java.io.InputStreamReader

const val INF = Long.MAX_VALUE
fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m) = br.readLine().split(" ").map { it.toInt() }
    val edges = mutableListOf<List<Int>>().apply {
        repeat(m) {
            add(br.readLine().split(" ").map { it.toInt() })
        }
    }
    val distance = Array(n + 1) { INF }
    if (bellmanFord(n, 1, edges, distance)) {
        for (i in 2..n) {
            println(if (distance[i] != INF) distance[i] else -1)
        }
        return
    }
    println(-1)
}

private fun bellmanFord(n: Int, start: Int, edges: List<List<Int>>, distance: Array<Long>): Boolean {
    distance[start] = 0
    for (i in 0 until n) {
        for (edge in edges) {
            val (current, next, cost) = edge
            if (distance[current] != INF && distance[next] > distance[current] + cost) {
                distance[next] = distance[current] + cost
                if (i == n - 1) {
                    return false
                }
            }
        }
    }
    return true
}

[wkdghdwns199]

https://youtu.be/Ppimbaxm8d8
이 분 설명 듣고 한 번 공부해보았슴다.. 어렵네요..!

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

def bellman_ford(start):
    dist[start] = 0

    for i in range(1,n+1):
        for j in range(m):
            now, next, cost = edges[j][0], edges[j][1], edges[j][2]
            if dist[now] != INF and dist[next] > dist[now] + cost:
                dist[next] = dist[now] + cost
                if i == n :
                    return True
    return False

n,m = map(int, input().split())
edges = []
dist = [INF] * (n+1)

for _ in range(m):
    a,b,c = map(int, input().split())
    edges.append((a,b,c))

negative_cycle = bellman_ford(1)
if negative_cycle :
    print(-1)
else :
    for i in range(2,n+1):
        if dist[i] == INF:
            print(-1)
        else :
            print(dist[i])

[fnzksxl]

@alstjr7437

저 부분에서 음수 가중치를 처리했다고 해도 다익스트라 알고리즘은 근본적으로 이 문제를 해결할 수 없습니다.
다익스트라 알고리즘은 최신화되지 않을 때까지 계속 최소거리를 갱신해나가는데, 노드가 서로 연결되어 있고 그 엣지가 모두
음수 가중치를 가지고 있다고 한 번 가정해보세요!