31-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 면접보는 승범이네 https://www.acmicpc.net/problem/17835

✔️ 소요된 시간

1h 30min

✨ 수도 코드

이번엔 다익스트라로 푼 문제를 가져왔습니다.

도시는 100,000개까지 가능하고 면접장의 개수도 그만큼 많아질 수 있기 때문에
각 도시로부터 다익스트라를 실행하여 면접장까지의 거리를 계산하는 것은 비효율적일 것이라고 생각했습니다.
그래서 면접장들로부터 다익스트라를 실행하여 최장거리의 도시를 찾았습니다.

해당 문제는 단방향 그래프 문제인데요.
면접장들로부터 다익스트라를 실행하기 위해
입력 받은 간선을 반대 방향으로 저장하였습니다.

그리고 아까 언급한대로 면접장의 개수도 도시의 개수만큼 많아질 수 있기 때문에
면접장마다 다익스트라를 수행하는 것은 비효율적이라고 합니다.
다익스트라 알고리즘이라고 하면 하나의 출발점에서 시작하는 것이 익숙한데
출발점을 한번에 넣어 여러 시작점에서 각 정점까지의 최단 경로를 구할 수 있습니다.

그렇게 구한 각 정점까지의 최단 경로 중 가장 먼 거리와 도시 번호를 출력하면 끝입니다.

📚 새롭게 알게된 내용

여러 시작점에서 각 정점까지의 최단 경로를 구하는 다중 시작점 다익스트라를 알게 되었습니다

[wnsmir]

지방러 입장에서 굉장히 따스한 문제네요,,

문제를 읽자마자 바로 다익스트라를 떠올렸습니다.
다만 생각이 흘러가는대로 다익스트라로 각도시에서 면접장까지의 거리를 구하게되면
1%이상은 시간초과가 났습니다. (예상은했지만,,)

생각을 좀 더 해본 결과 면접장들에서 각도시의 거리를 모두 구해두고, 이를 저장해둔 배열에서 도시번호와 거리를 출력하면 될것 같았습니다.

한가지 생각해야했던건
문제는 단방향이고, 도시에서 면접장까지의 길이 보장되어있다는 것입니다.
즉 면접장에서 도시까지의 길을 구하기 위해서는 역방향으로 저장해주어야 합니다.

그 외에는 heapq를쓴 담백한 다익스트라문제였다고 생각합니다.

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

import heapq
def dijkstra(spots, graph, N):
    INF = 10**18
    dist = [INF] * (N+1)
    heap = []

    for start in spots:
        dist[start] = 0
        heapq.heappush(heap, (0, start))
    
    while heap:
        d, cur = heapq.heappop(heap)
        if dist[cur] < d:
            continue
        # WTG == Where To Go
        for WTG, cost in graph[cur]:
            if dist[WTG] > d + cost:
                dist[WTG] = d + cost
                heapq.heappush(heap, (dist[WTG], WTG))
    
    return dist


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

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

spots = list(map(int, input().split()))

farest_dist = -1
city = 0
dist = dijkstra(spots, graph, N)

for i in range(1, N+1):
    if dist[i] > farest_dist:
        farest_dist = dist[i]
        city = i
    if dist[i] == farest_dist and i < city:
        city = i

print(city)
print(farest_dist)

아 참고로 저는주로 INF에 987654321을 쓰는데
이문제에선 간선의 수가 100000, 가중치는 100000이라 10^10까지 커질 수 있어 한번 틀렸습니다..
앞으로는 10*18을 써야겠다는 교훈을 얻어갑니다~

[9kyo-hwang]

순간 뭐에 홀렸을까요? 면접장 -> 도시 역방향 그래프를 구축해서 풀면 되지 하고 생각 바로 떠올렸는데 왜 시간 초과 난다고 생각했을까요... 순간 각 면접장 노드마다 다익스트라를 다 돌려야한다고 착각한 것 같습니다 허허...

이렇게 방향 그래프를 뒤집어서 저장한 뒤, 모든 출발지 -> 목적지가 아닌 목적지 -> 모든 출발지로 거리 정보를 얻는 건 국밥같은 유형이죠. 실전에서도 잘 떠올리시면 좋을 것 같습니다.

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M, K; cin >> N >> M >> K;
    
    vector<vector<pair<int, long long>>> graph(N + 1);
    while(M--) {
        int U, V, C; cin >> U >> V >> C;
        graph[V].emplace_back(U, C);    // reverse
    }
    
    using Node = pair<long long, int>;
    priority_queue<Node, vector<Node>, greater<>> pq;
    vector<long long> distances(N + 1, 1e10);
    unordered_set<int> cities; cities.reserve(K);
    
    while(K--) {
        int node; cin >> node;
        pq.emplace(0, node);
        distances[node] = 0;
        cities.emplace(node);
    }
    
    while(!pq.empty()) {
        const auto [du, u] = pq.top();
        pq.pop();
        
        if(distances[u] < du) {
            continue;
        }
        
        for(const auto& [v, dv] : graph[u]) {
            if(du + dv < distances[v]) {
                distances[v] = du + dv;
                pq.emplace(distances[v], v);
            }
        }
    }
    
    long long maxDistance = 0;
    long long minNode = 0;
    for(int node = 1; node <= N; ++node) {
        if(cities.count(node)) {
            continue;
        }
        
        if(distances[node] > maxDistance) {
            maxDistance = distances[node];
            minNode = node;
        }
    }
    
    cout << minNode << "\n" << maxDistance;

    return 0;
}

[kangrae-jo]

재미있는 문제군요.

경로를 반대로 돌려서 저장하는 것과 면접장을 source로 두어서 다익스트라를 돌리는 것을 생각해냈어요.
근데 왜 문제가 안풀리는 거지.... 라고 생각을 하고 gpt에 넣어봤어요...
원인을 알고 한숨만 나오더라구요.

제가 처음에 짠 코드는 아래와같아요.

while (!pq.empty()) {
        auto [dist, cur] = pq.top(); 
        pq.pop();

        if (dist > distances[cur]) continue;

        for (auto [dist_, next] : graph[cur]) {
            long long newDist = dist + dist_;
            if (newDist < distances[next]) {
                distances[next] = newDist;
                pq.push({newDist, next});
            }
        }
    }

for문에서 꺼낼때 반대로 꺼내고 있었더라구요...
큐에는 c++의 pq를 활용하기 위해서 {거리, 노드} 로 저장해놨거든요. 그래서 자주 헷갈려하는 부분입니다.

그리고 이후에도 몇번 틀려서 리미트를 longlong으로 바꾸어주었고 통과했습니다 ㅎㅎ

솔루션 자체는 올바르게 생각해냈다는 것에 큰 의미를 둡니다요.

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const long long INF = 1e18;

int N, M, K;
vector<vector<pair<int, int>>> graph;
vector<long long> distances;

void solution(vector<int>& places) {
    priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> pq;
    distances.assign(N + 1, INF);

    for (int src : places) {
        pq.push({0, src});
        distances[src] = 0;
    }

    while (!pq.empty()) {
        auto [dist, cur] = pq.top(); 
        pq.pop();

        if (dist > distances[cur]) continue;

        for (auto [next, dist_] : graph[cur]) {
            long long newDist = dist + dist_;
            if (newDist < distances[next]) {
                distances[next] = newDist;
                pq.push({newDist, next});
            }
        }
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    cin >> N >> M >> K;

    graph = vector<vector<pair<int, int>>>(N + 1);
    for (int i = 0; i < M; i++) {
        int U, V, C;
        cin >> U >> V >> C;
        graph[V].push_back({U, C});
    }

    vector<int> places(K);
    for (int i = 0; i < K; i++) {
        cin >> places[i];
    }

    solution(places);

    int answer = 1;
    for (int i = 2; i <= N; i++) {
        if (distances[i] > distances[answer]) answer = i;
    }

    cout << answer << '\n' << distances[answer] << '\n';

    return 0;
}

[g0rnn]

당연히 다익스트라를 통해 풀어야한다곤 생각했지만 답이 떠오르지 않았습니다. 어차피 면접장의 최대 개수는 V(모든 도시의 수)이기 때문에 O(VElogV)가 될거라 생각해서 시간초과를 예상했었죠.

20분 고민하다가 정말 답이 안보여서 이번에도 답지를 봤습니다. 솔루션이 저랑 비슷했는데 큐에 미리 모든 출발지를 넣고 distance배열을 초기화할 줄을 정말 몰랐네요.!

어떤 최소경로 문제도 다익스트라로 풀릴 수 있다는걸 다시금 확인했습니다 :)

근데 너무 오랜만이라... 다익스트라를 구현하는데 살짝 애먹은.. 분발하겠습니다 고생하셨어요~

package beakjoon;

import java.io.*;
import java.util.*;

public class Sol17835 {

    static int V, E, K;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        V = Integer.parseInt(st.nextToken());
        E = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());

        List<List<int[]>> graph = new ArrayList<>();
        List<Integer> spot = new ArrayList<>();
        for (int i = 0; i <= V; i++) {
            graph.add(new ArrayList<>());
        }

        for (int i = 0; i < E; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());

            graph.get(v).add(new int[]{u, c});
        }
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < K; i++) {
            spot.add(Integer.parseInt(st.nextToken()));
        }
        br.close();

        long[] distance = dijkstra(graph, spot);
        long maxDist = -1;
        int maxCity = 0;
        for (int i = 1; i <= V; i++) {
            if (distance[i] > maxDist) {
                maxCity = i;
                maxDist = distance[i];
            }
        }
        System.out.println(maxCity);
        System.out.println(maxDist);
    }

    private static long[] dijkstra(List<List<int[]>> graph, List<Integer> spot) {
        PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> Long.compare(a.dist, b.dist));
        long[] distance = new long[V + 1];
        Arrays.fill(distance, Long.MAX_VALUE);

        for (Integer s : spot) {
            distance[s] = 0L;
            pq.offer(new Node(s, 0L));
        }
        while (!pq.isEmpty()) {
            int city = pq.peek().city;
            long dist = pq.poll().dist;

            if (dist > distance[city]) continue;

            for (int[] next : graph.get(city)) {
                long nextDist = next[1] + dist;
                if (nextDist < distance[next[0]]) {
                    pq.offer(new Node(next[0], nextDist));
                    distance[next[0]] = nextDist;
                }
            }
        }
        return distance;
    }

    static class Node {
        int city;
        long dist;
        public Node(int city, long dist) {
            this.city = city;
            this.dist = dist;
        }
    }
}