17-SeongHoonC

[SeongHoonC]

🔗 문제 링크

특정한 최단 경로

✔️ 소요된 시간

2시간

✨ 수도 코드

start 에서 출발했을 때 end 까지의 최단거리를 구하는 다익스트라 알고리즘을 짠다.

결국 V1 V2 를 지나가는 최단거리 경우의 수는 두 가지가 존재한다.
1 - v1 - v2 - N
1 - v2 - v1 - N

dijkstra(1,v1) + dijkstra(v1,v2) + dijkstra(v2,N)
dijkstra(1,v2) + dijkstra(v2,v1) + dijkstra(v1,N)

둘 중에 최소값이 답이 된다.

max 값을 1억으로 잡았다가 최대 200,000 * 1000 을 보고 안된다는 것을 깨달았다. 걍 9억으로 늘려줬다

또한 억단위 합 계산 때문에 타입을 Long 으로 변경했다.

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
import kotlin.math.min

private const val INF = 987_654_321L

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))

    val (N, E) = br.readLine().split(" ").map { it.toInt() }
    val graph = Array(N + 1) { mutableListOf<Pair<Int, Long>>() }
    for (i in 0 until E) {
        val (start, end, cost) = br.readLine().split(" ").map { it.toInt() }
        graph[start].add((end to cost.toLong()))
        graph[end].add((start to cost.toLong()))
    }

    val (v1, v2) = br.readLine().split(" ").map { it.toInt() }
    // 1 to v1 + v1 to v2 + v2 to N
    val cost1 = dijkstra(N, 1, v1, graph) + dijkstra(N, v1, v2, graph) + dijkstra(N, v2, N, graph)
    // 1 to v2 + v2 to v1 + v1 to N
    val cost2 = dijkstra(N, 1, v2, graph) + dijkstra(N, v2, v1, graph) + dijkstra(N, v1, N, graph)

    val answer = min(cost1, cost2)
    println(if (answer >= INF) -1 else answer)
}

// start to end 최단거리 구하기
private fun dijkstra(N: Int, start: Int, end: Int, graph: Array<MutableList<Pair<Int, Long>>>): Long {
    if (start == end) {
        return 0
    }
    val pq = PriorityQueue<Edge>()
    val distance = Array(N + 1) { INF }

    distance[start] = 0
    pq.add(Edge(start, 0))

    while (pq.isNotEmpty()) {
        val (now, dist) = pq.poll()
        // 현재 노드에서 갈 수 있는 모든 엣지 중 최단거리이면 큐에 넣는다.
        for ((next, cost) in graph[now]) {
            val nextCost: Long = dist + cost
            if (distance[next] > nextCost) {
                distance[next] = nextCost
                pq.add(Edge(next, nextCost))
            }
        }
    }

    return distance[end]
}

data class Edge(val start: Int, val cost: Long) : Comparable<Edge> {

    // 거리(비용)가 짧은 것이 높은 우선순위를 가지도록 설정
    override operator fun compareTo(other: Edge): Int {
        return if (this.cost < other.cost) -1 else 1
    }
}

📚 새롭게 알게된 내용

Max 값을 잘 정하자..
Comparable 객체를 만들면 PriorityQueue 의 타입으로 지정 가능하다.

[alstjr7437]

그래프 최단 경로 문제를 안풀고 개념을 까먹은지 오래 되서 다익스트라 함수 부분은 인터넷을 참고 했네요!!

아이디어는 기본적으로 똑같이 했습니다!!
v까지 가는데
우선

1. 처음부터 v1,v2까지 가는 경우 계산
2. v1에서 v2, v가는 경우 계산
3. v2에서 v1, v가는 경우 계산

들리면 되니까 결국 3개의 다익스트라를 돌리고 아래를 통해 결과값을 찾아 냈습니다!!

1. start -> v1 -> v2 -> v 경우
2. start -> v2 -> v1 -> v 경우
3. 1,2중에 더 작은 값으로 갈 수 있는 경우가 정답

from heapq import * 
import sys

input = sys.stdin.readline
# 최대값 선언
INF = int(1e9)

v, e = map(int, input().split())
graph = [[] for _ in range(v + 1)]

for _ in range(e):
    x, y, cost = map(int, input().split())
    graph[x].append((y, cost))
    graph[y].append((x, cost))


def dijkstra(start):
    distance = [INF] * (v + 1)
    q = []
    heappush(q, (0, start))
    distance[start] = 0

    while q:
        dist, now = heappop(q)

        if distance[now] < dist:
            continue

        for i in graph[now]:
            cost = dist + i[1]

            if distance[i[0]] > cost:
                distance[i[0]] = cost
                heappush(q, (cost, i[0]))

    return distance

v1, v2 = map(int, input().split())

v_distance = dijkstra(1)
v1_distance = dijkstra(v1)
v2_distance = dijkstra(v2)

v1_path = v_distance[v1] + v1_distance[v2] + v2_distance[v]
v2_path = v_distance[v2] + v2_distance[v1] + v1_distance[v]

result = min(v1_path, v2_path)
print(result if result < INF else -1)

[alstjr7437]

따로 Readme에 문제 선정은 일부러 추가를 안하신건가요!!?

[alstjr7437]

따로 우선순위 큐 데이터 구조까지 만들어서 해야하는건가요 코틀린에서는????

[SeongHoonC]

그렇습니다 하하

[fnzksxl]

오,, 예전에 재밌게 풀었던 문제네요. 저도 똑같이 풀었습니다
중간 지점까지의 다익스트라랑 그 지점부터 끝까지의 다익스트라를 돌리는 아이디어!

import sys
import heapq

def dijkstra(start,end):
    distLst=[inf]*(n+1)
    q=[]
    heapq.heappush(q,(0,start))
    distLst[start]=0

    while q:
        dist,node=heapq.heappop(q)
        if distLst[node]<dist:
            continue
        for weight,edge in graph[node]:
            cost=distLst[node]+weight
            if cost<distLst[edge]:
                distLst[edge]=cost
                heapq.heappush(q,(cost,edge))
    return distLst[end]
        
inf=sys.maxsize
n,e=map(int,sys.stdin.readline().split())

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

for _ in range(e):
    e1,e2,weight=map(int,sys.stdin.readline().split())
    graph[e1].append((weight,e2))
    graph[e2].append((weight,e1))

v1,v2=map(int,sys.stdin.readline().split())

path1=dijkstra(1,v1)+dijkstra(v1,v2)+dijkstra(v2,n)
path2=dijkstra(1,v2)+dijkstra(v2,v1)+dijkstra(v1,n)

if path1 >= inf and path2>= inf:
    print(-1)
else:
    print(min(path1,path2))