54-tgyuuAn

[tgyuuAn]

🔗 문제 링크

미확인 도착지

✔️ 소요된 시간

2시간

오래간만에.... 적수를 만났다...

✨ 수도 코드

일단 이 문제는 문해력을 많이 요하는 문제인 것 같다.

문제 이해하는 데만 20분 정도 걸렸다.

아래와 같은 그래프가 주어졌을 때,

회색 노드가 시작 지점이다.

이 때, 검은색 노드가 목적지의 후보가 될 수 있는 노드들인데,

회색에서 검은색으로 최소경로로 뻗었을 때 점선으로 주어진 경로 <g, h>를 지날 수 있는 검은색 노드들을 반환하면 된다.

그러니까,,, 정리해보면 위에서 목적지 후보가 될 수 있는 노드는 5, 6번 노드인데,

시작 노드인 2번 노드에서 뻗으면 5번 노드는 바로 5코스트를 사용해서 2-> 5번 경로를 타고 가는 것이 가장 빠르다.

반면, 6번 노드는 2-> 3-> 6번 경로로 가는 것이 6 코스트를 써서 가장 빠르다.

이 때, 6번 노드로 가는 최소 경로에 점선 노드인 1 -> 3 노드가 있으므로 6번 노드를 반환하면 되는 것이다.

그럼 이 문제를 어떻게 풀면 되느냐?!

일단 시작 노드가 하나가 주어진 상태로 최소 코스트로 각 노드마다 길을 뻗어야 하므로 다익스트라를 사용하는 것이 명확하다.

(다익스트라에 대한 설명은 디스코드 채널 알고리즘 노트에 있어요!)

그러면 어떻게 하면 해당 노드까지의 최소 경로에 <g, h> 경로가 있음을 파악할 수 있을까?

조금만 생각해보면 은근 간단한데,

아래와 같이 기존 다익스트라에는 힙 혹은 우선순위 큐에 해당 <노드까지의 코스트, 노드>만 저장했지만,

heap = [[0,start_node]]

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

is_via = False
heap = [[0,start_node, is_via]]

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

    for next_node in graph[now_distance]:
        // 기존 로직

        if (now_node, next_node) == (g, h) or (now_node, next_node) == (h, g):
            new_via= True

        heappush(heap, [new_distance, next_node, new_via])

와 같이 중간에 경로에 대한 정보를 가지고 해당 경로를 지났는 지, 지나지 않았는 지만 체크하면 된다.

이렇게만 하면 풀릴 줄 알았다.

근데 복병이 있었다.......

아래 경우를 생각해보자.

1
6 6 2
1 2 3
1 2 1
2 3 2
3 4 1
4 5 1
1 6 4
6 5 1
4
5
ans : 4 5

목적지 후보 노드 4번 노드로 가는 길은 아래와 같이 명확하다.

4번 노드는 반드시 냄새가 나는 경로를 지나갈 수 밖에 없다.

하지만 5번 노드는?

아래와 같이 1-> 6-> 5 경로로 가는 것과,

1->2->3->4->5 의 경로로 가는 것의 코스트가 같다.

사실 이럴 경우에는 냄새가 나는 경로로 가는 최소 경로가 있기 때문에 답에 포함을 하는 것이 맞다.

그럼 위 경우에서 답을 도출해내려면 똑같은 코스트에서 갈 수 있는 경로가 여러 가지 일 때,

냄새가 나는 경로를 지난 것을 먼저 우선순위 큐 혹은 힙에서 뽑아내야만 한다.

어떻게 우선순위 큐에서 가중치를 잘 조정해서 냄새가 나는 경로가 있는 것을 먼저 뽑으면 된다.

이를 해결하는 방법은

heappush(heap, [0, start_node, 1])
    flag = [1 for _ in range(cnt_node+1)]
    
    while heap:
        now_cost, now_node, now_flag = heappop(heap)

        if now_node in visited: continue
        visited.add(now_node)
        
        if flag[now_node] == 1 and now_flag == 0: flag[now_node] = 0

        for next_node in graph[now_node]:
            cost = graph[now_node][next_node]

            if (now_cost + cost) > table[next_node]: continue
            
            table[next_node] = now_cost + cost
            
            new_flag = now_flag
            # 만약, 지금 움직이려는 도로가 냄새가 나는 도로였을 경우 flag를 0로 바꿈
            if (now_node, next_node) in {(g, h), (h, g)}: new_flag = 0
    
            heappush(heap, [now_cost + cost, next_node, new_flag])

냄새나는 경로를 지났을 때를 나타내는 is_via의 값을

경로를 지났을 경우 0으로 두고,

경로를 지나지 않았을 경우 1로 두어서

우선순위 큐 혹은 힙에서 경로를 지난 경우를 먼저 도출하게 하면 된다.

이거 마지막 꺼 처리한다고 시간 좀 오래 걸렸따.... ㅜㅜㅜㅜㅜㅜㅜㅜㅜㅜㅜㅜ

도움이 많이 됐던 글 1
도움이 많이 됐던 글 2

📚 새롭게 알게된 내용

[alstjr7437]

아니 이거 그냥 문제만 읽고 이해하려다가 도저히 문해력이 안되서 결국 인터넷 검색을 했네요,...

그냥 다익스트라 알고리즘에다가 최단 경로를 보는데 해당 최단 경로가 점선을 지나게 되면 True로 바꿔서 하면 되겠군요..!!
맞나요...?

일단 이해하고 코드를 구현해보려고요!(사실 다익스트라 오래만이라 까먹어서 노트 보고 다시 공부해야할듯..)

[tgyuuAn]

아니 이거 그냥 문제만 읽고 이해하려다가 도저히 문해력이 안되서 결국 인터넷 검색을 했네요,...

그냥 다익스트라 알고리즘에다가 최단 경로를 보는데 해당 최단 경로가 점선을 지나게 되면 True로 바꿔서 하면 되겠군요..!! 맞나요...?

일단 이해하고 코드를 구현해보려고요!(사실 다익스트라 오래만이라 까먹어서 노트 보고 다시 공부해야할듯..)

맞습니다 맞고요 ~ ~~~~

[H0ngJu]

문제 읽고 ... 어디서 어떻게 접근해야할지 아예 1도 감이 안와서
태규님 PR + 다른 풀이 글 정독했습니다 ..

풀이를 보고 이해하는데 한참 걸렸네요 ......... 😅

마아침 지금 전공에서 다익스트라 하고 있었는데 공부하고 다시 이 문제 도전해보겠읍니다 🔥🔥🔥🔥

PS.

요 부분 오타인 것 같은데 1->3->6 인거죠 ??

[SeongHoonC]

저랑 풀이가 완전 달라서 남겨봅니다.

s,g,h 에서 출발 최단거리를 구하고..

s -> target 이 아래 두개 중 하나와 값이 같은지 비교합니다.

1. s 에서 g 까지 최단거리 + h 에서 목적지까지 최단거리 + g 에서 h 비용
2. s 에서 h 까지 최단거리 + g 에서 목적지까지 최단거리 + g 에서 h 비용

const val INF_1 = 987_654_321
fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val T = br.readLine().toInt()

    repeat(T) {
        program(br)
    }
}

private fun program(br: BufferedReader) {
    val (n, m, t) = br.getIntInputs()
    val (s, g, h) = br.getIntInputs()

    val graph = Array(n + 1) { Array(n + 1) { INF_1 } }

    repeat(m) {
        val (a, b, d) = br.getIntInputs()
        graph[a][b] = d
        graph[b][a] = d
    }
    val distances = dijkstra(graph = graph, start = s, n = n)
    val distanceFormH = dijkstra(graph, h, n)
    val distanceFormG = dijkstra(graph, g, n)
    val gToHCost = graph[g][h]

    val candidates = (0 until t).map { br.readLine().toInt() }

    val answer = candidates.filter { candi ->
        distances[candi] == distances[g] + distanceFormH[candi] + gToHCost || distances[candi] == distances[h] + distanceFormG[candi] + gToHCost
    }

    println(answer.sorted().joinToString(" "))
}

private fun dijkstra(graph: Array<Array<Int>>, start: Int, n: Int): Array<Int> {
    val queue = ArrayDeque<Int>()
    queue.add(start)

    val distance = Array(n + 1) { INF_1 }
    distance[start] = 0
    while (queue.isNotEmpty()) {
        val now = queue.removeFirst()
        for (i in 1 until graph.size) {
            val cost = distance[now] + graph[now][i]
            if (cost >= distance[i]) {
                continue
            }
            distance[i] = cost
            queue.add(i)
        }
    }
    return distance
}

private fun BufferedReader.getIntInputs() = readLine().split(" ").map { it.toInt() }

[tgyuuAn]

저랑 풀이가 완전 달라서 남겨봅니다.

s,g,h 에서 출발 최단거리를 구하고..

s -> target 이 아래 두개 중 하나와 값이 같은지 비교합니다.

1. s 에서 g 까지 최단거리 + h 에서 목적지까지 최단거리 + g 에서 h 비용
2. s 에서 h 까지 최단거리 + g 에서 목적지까지 최단거리 + g 에서 h 비용

const val INF_1 = 987_654_321
fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val T = br.readLine().toInt()

    repeat(T) {
        program(br)
    }
}

private fun program(br: BufferedReader) {
    val (n, m, t) = br.getIntInputs()
    val (s, g, h) = br.getIntInputs()

    val graph = Array(n + 1) { Array(n + 1) { INF_1 } }

    repeat(m) {
        val (a, b, d) = br.getIntInputs()
        graph[a][b] = d
        graph[b][a] = d
    }
    val distances = dijkstra(graph = graph, start = s, n = n)
    val distanceFormH = dijkstra(graph, h, n)
    val distanceFormG = dijkstra(graph, g, n)
    val gToHCost = graph[g][h]

    val candidates = (0 until t).map { br.readLine().toInt() }

    val answer = candidates.filter { candi ->
        distances[candi] == distances[g] + distanceFormH[candi] + gToHCost || distances[candi] == distances[h] + distanceFormG[candi] + gToHCost
    }

    println(answer.sorted().joinToString(" "))
}

private fun dijkstra(graph: Array<Array<Int>>, start: Int, n: Int): Array<Int> {
    val queue = ArrayDeque<Int>()
    queue.add(start)

    val distance = Array(n + 1) { INF_1 }
    distance[start] = 0
    while (queue.isNotEmpty()) {
        val now = queue.removeFirst()
        for (i in 1 until graph.size) {
            val cost = distance[now] + graph[now][i]
            if (cost >= distance[i]) {
                continue
            }
            distance[i] = cost
            queue.add(i)
        }
    }
    return distance
}

private fun BufferedReader.getIntInputs() = readLine().split(" ").map { it.toInt() }

1. 원래 시작지 에서 다익스트라 한 번,
2. G 혹은 H 노드 에서 각각 한번 씩

총 다익스트라가 3번 돌아가기 때문에 조금은 비효율적일 수 있는데 저는 생각도 못해본 풀이네요...

소중합니다..

뭔가 이런 풀이로 풀어야 하는 문제가 있었는데,,, 잠시만요 ..

[tgyuuAn]

@SeongHoonC 찾았따 #84 이거도 한 번 풀어보시는 거 추천드립니다!!

3명의 리뷰어 중에서 혼자 풀어주셨네요.... 정말 감사드립니다 (__)

@alstjr7437 @H0ngJu 퍽퍽

[SeongHoonC]

@SeongHoonC 찾았따 #84 이거도 한 번 풀어보시는 거 추천드립니다!!

3명의 리뷰어 중에서 혼자 풀어주셨네요.... 정말 감사드립니다 (__)

@alstjr7437 @H0ngJu 퍽퍽

이미 풀었지용 ㅎㅎ