48-tgyuuAn

[tgyuuAn]

🔗 문제 링크

골목길

✔️ 소요된 시간

1시간 20분

✨ 수도 코드

• 하나의 출발지에서 여러 개의 목적지까지 걸리는 데 최소 비용을 구하는 경우 : 다익스트라
• 여러 개의 출발지에서 여러 개의 목적지로 걸리는 데 최소 비용을 구하는 경우 : 플로이드 워셜
• 음수 가중치가 있는 경우, 음수 가중치로 인해 음수 사이클이 발생할 것 같은 경우 : 벨만 포드

이 문제는 아래와 같이 음수 가중치가 있으니까 벨만 포드를 사용함을 쉽게 떠올릴 수 있다.

벨만포드의 시간 복잡도는 $총 노드의 수 * 간선의 갯수$ 이므로 총 200만으로 시간 복잡도 안으로도 세이프 가능하다.

벨만 포드의 자세한 구현 방법은 @gjsk132 에게 위임..

오후에 디스코드 알고리즘 노트에 올라올 것이다 허허.

++ 글 올라왔습니다. 디스코드 채널에 알고리즘 노트 읽어보세요!

다시 문제로 돌아와서,

그러면 이렇게 생각할 수 있다.

'음수 사이클이 발생하는 경우 "-1" 을 출력하면 되겠다 ...!'

'아, 음수 사이클이 발생하지 않더라도 간선이 마지막 노드 까지 연결되지 않을 경우도 있으니까, 마지막 노드로 연결되지 않을 경우도 "-1"을 출력해야겠다.'

이렇게만 사고하고 코드를 작성해나갔다.

import sys

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

N, M = map(int, input().split())
edge = []

# 간선 정보 받음
for _ in range(M):
    start, destination, cost = map(int,input().split())
    edge.append([start, destination, cost])
    
# 초기 세팅
board = [-int(1e9) for _ in range(N+1)]
board[1] = 0

# 최적의 경로를 찾기 위해 역추적 하기 위해서 이전 노드를 기록
prev_node = [-1 for _ in range(N+1)]

for _ in range(N-1):
    for start, destination, cost in edge:
        if board[destination] < board[start] + cost:
            board[destination] = board[start] + cost
            prev_node[destination] = start

for start, destination, cost in edge:
    # 사이클 발생
    if board[destination] < board[start] + cost:
        print(-1)
        break

# 사이클이 없을 경우
else: 
    answer = []
    now = N
    while now != 1:
        answer.append(now)
        now = prev_node[now]
    answer.append(now)
    
    print(*answer[::-1])

# 총 간선 = 2만개,
# 총 노드 = 100개
# 벨만 포드 = ( 간선 X 노드 ) -> 200만 시간 복잡도 가능.

위 코드를 제출하고나니,

정답 퍼센트가 쭉쭉 올라가서 맞춘 줄 알고 좋아했다.

근데 76퍼에서 계속 걸렸다.

흠.. 도대체 어디가 문제였던 걸까..

근데 골드 1치고 난이도가 너무 쉬운 것 같아서 다시 문제를 꼼꼼히 읽어보았다.

아래 문장이 내 이목을 끌었다.

흠... 분명 최적의 경로가 아래 경우 말고도 다른 경우가 있구나 생각을 했다.

'음수 사이클이 발생하는 경우 "-1" 을 출력하면 되겠다 ...!'

'아, 음수 사이클이 발생하지 않더라도 간선이 마지막 노드 까지 연결되지 않을 경우도 있으니까, 마지막 노드로 연결되지 않을 경우도 "-1"을 출력해야겠다.'

근데 도저히 아무리 봐도 떠오르지가 않는다.

그래서 질문 게시판에서 반례를 뒤졌다.

아뿔싸....

"사이클이 있더라도, 해당 사이클이 시작 지점 - 목표 지점 과 연관이 없는 경우 최적의 경로를 찾을 수 있다."

즉, 위의 반례를 보면 2번과 3번 노드는 사이클을 만들어 무한 루프를 돌기 때문에 위 예시에서는 사이클이 존재한다고 할 수 있다.

하지만, 시작 지점인 1번과 목표 지점인 4번 노드는 사이클에 포함되어 있지 않으므로, 최적의 경로를 만들 수 있다.

그러면 벨만 포드를 진행하면서, 음수 사이클이 발생함을 파악한 순간 해당 노드를 기준으로 BFS 혹은 DFS를 돌려서 연관되어 있는 노드를 파악한다.

이 과정에서 시작 지점인 1번 노드와 목표 지점인 N번 노드가 포함되어 있으면 바로 -1을 출력하고,

해당 노느들이 포함되지 않았을 경우 사이클이 없을 때와 같이 시작 지점부터 마지막 지점까지 연결될 수 있는 지 체크한다.

끝 지점 까지 이어진다면 해당 경로를 출력, 아닐 경우 -1을 출력.

📚 새롭게 알게된 내용

[gjsk132]

벨만 포드의 자세한 구현 방법은 @gjsk132 에게 위임..

오후에 디스코드 알고리즘 노트에 올라올 것이다 허허.

어라라

[H0ngJu]

다익스트라는 개념만 알고 있었고, '플로이드 워셜', '벨만포드'는 처음 들어봤네요 ㄷㄷ
나영님과 태규님 덕분에 알고리즘 하나 또 줍줍 해갑니다 !!

다익스트라에서 음의 가중치 때문에 무한루프를 돌게 되는 문제가 발생해서 벨만 포드를 사용하고, 양의 가중치만 있는 경우에는 다익스트라를 사용하는 것이 더 효울적이다!

아직 이 문제를 풀기엔 다익스트라도 제대로 모르는 것 같아서 저장해두었다가 다익스트라 공부하고 다시 풀어보겠습니닷 !! 🔥🔥

소마 축하드립니다 대장님 😎🎉

[H0ngJu]

사소한거긴 한데, start 뒤에 ,<< 이건 별 의미 없는 건가요? 🤔

[tgyuuAn]

집합을 선언할 때에는 항이 하나 밖에 없을 때 콤마를 넣어줘야 해요!

위 코드는

visited = set()
visited.add(start)

랑 동일하게 작동합니다!

[pknujsp]

드디어 풀었습니다
5시간 연속으로 잡은 문제는 이게 처음인거 같네요

INF = -int(1e9)

N, M = map(int, input().split())
edges = [[] for _ in range(N + 1)]

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

dist = [INF] * (N + 1)
dist[1] = 0
path = list(range(N + 1))

for _ in range(N - 1):
    for u in range(1, N + 1):
        for v, w in edges[u]:
            if dist[u] != INF and dist[v] < dist[u] + w:
                dist[v] = dist[u] + w
                path[v] = u

connected_start_to_end = False
queue = deque()
visited = set()

for u in range(1, N + 1):
    for v, w in edges[u]:
        if dist[u] != INF and dist[v] < dist[u] + w:
            queue.append(v)
            visited.add(v)

while queue:
    current = queue.popleft()
    
    if current == 1 or current == N:
        connected_start_to_end = True
        break

    for v, w in edges[current]:
        if v not in visited:
            visited.add(v)
            queue.append(v)

if connected_start_to_end:
    print(-1)
    exit()

if dist[N] == INF:
    print(-1)
    exit()

q = deque()
x = N

while x != path[x]:
    q.appendleft(x)
    x = path[x]
    
q.appendleft(x)
print(*q)

밑에 코드가 76%에서 막혔던 코드예요

아까 전 에는 사이클이 있더라도, 해당 사이클이 시작 지점 - 목표 지점 과 연관이 없는 경우 최적의 경로를 찾을 수 있다.
태규님 내용 보기전에는 이 내용을 아예 생각하지도 못했었고, 뒤에 이거 처리하는데 한 3시간 걸렸습니다

edges = [list(map(int, input().split())) for _ in range(M)]

dist = [INF] * (N + 1)
dist[1] = 0
path = list(range(N + 1))

for n in range(N):
    updated = False
    for u, v, w in edges:
        if dist[u] != INF and dist[v] < dist[u] + w:
            if n == N - 1:
                print(-1)
                exit()
                
            dist[v] = dist[u] + w
            path[v] = u
            updated = True
                
    if not updated:
        break

if dist[N] == INF:
    print(-1)
    exit()

q = deque([N])
x = path[N]

while x != path[x]:
    q.appendleft(x)
    x = path[x]

q.appendleft(1)
print(*q)