14-wnsmir

[wnsmir]

🔗 문제 링크

이전문제의 흐름을 이어받아 최단거리문제 하나 더 가져와보았습니다.

N개의 도시가 있고, M개의 통로가 있습니다. N개의 도시중 C라는 도시가 위험에 쳐해 상황을 알리고자 최대한 많은 도시로 메시지를 보내려합니다.
메시지는 C에서 출발하여 각 도시 사시에 설치된 통로를 거쳐 최대한 많이 퍼져나갑니다.
통로는 방향성을 가지며, 통로마다 가중치가 주어집니다.
각 도시의 번호와 통로가 설치되어있는 정보가 주어졌을때 도시 C에서 보낸 메시지를 받게되는 도시의 개수는 총 몇개이며 도시들이 모두 메시지를 받는 데 까지 걸리는 시간은 얼마인지 계산하는 프로그램을 작성하시오.

첫째줄에 도시의개수 (1 <= N <= 30,000), 통로의 개수 (1 <= M <= 200,000), 1<=C<=N)이 주어진다.
둘째줄부터 X에서 Y로 이어지는 통로의 가중치 즉 (X, Y, X)가 주어진다.

입력 예시
3 2 1
1 2 4
1 3 2

츨력예시
2 4

✔️ 소요된 시간

1h 30min

✨ 수도 코드

이전문제는 노드와 간선의 개수가 적어 플루이드위셜 문제로도 가능했지만, 이문제는 노드와 간선의 개수가 굉장히 많아 일반 다익스트라로도 풀이가 불가능합니다. 따라서 개선된 우선순위큐를 사용한 다익스트라를 활용해야합니다.
따라서 시간이 많이 소요되었습니다

참고용 블로그 : https://kimig.tistory.com/30

이문제가 최단거리로 치환될 수 있었던 이유는 가장 먼 도시까지 도달하는 시간이 모든도시에 전보가 전달되는 시간이고 다익스트라 알고리즘이 짚고 넘어간 노드의 개수가 전보가 전달된 도시의 수이기 때문입니다.

📚 새롭게 알게된 내용

방문하지않은 도시, 닿지않는 도시를 나타낼때 INF를 지정해주는데
987654321로 지정하면 자릿수 틀리지않고 편안하게 진행할 수 있습니다!

[kangrae-jo]

다익스트라구현은 처음 인 것 같네요.
( 예전에 한 것 같기도 한데 기억이 하나도 안나네요... )

그래서 개념을 조금 찾아봤고 아주아주 간단하게 정리도 해봤습니다.

다익스트라 알고리즘은 그래프에서 하나의 정점(출발점)으로부터
다른 모든 정점까지의 최단 경로를 찾는 알고리즘입니다. 
( One to All )

가중치가 있는 그래프에서 사용되며, 간선의 가중치가 음수가 없는 경우에만 올바르게 동작합니다.
( 음수 가중치가 있다면 최소를 찾아가기 때문에 무한 루프가 생김 )

처음에는 우선순위 큐를 사용하지 않고 그냥 큐를 썼습니다.
그래도 문제는 풀리더라구요...
그러고 리뷰를 달기위해서 준용님 설명을 읽어봤습니다.

그런데... 준용님은 우선순위 큐를 사용하여서 최소 가중치부터 계산하는 로직으로 구현하신 것을 봤습니다.
왜 그럴까 생각을 해봤는데 그냥 큐를 사용한다면 가중치 배열이 계속해서 업데이트되는 문제가 생길 수 도 있을 것 같습니다.
따라서 이 문제같이 입력이 많은 문제에서는 시간 복잡도에 큰 영향을 끼칠 것이라고 생각했습니다.
그래서 저도 우선순위 큐로 고치고 문제를 다시 풀어봤습니다...

또 균호님이 소개해주셨던 c++ 문법중에

auto [a, b] = c;

이 로직 잘 사용했습니다. 감사합니다~

CPP CODE

#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#include <limits>

using namespace std;

int N, M, C;
vector<vector<pair<int, int>>> graph;
vector<int> distances;

void solution() {
    distances = vector<int>(N + 1, INT_MAX);

    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.push({0,C});
    distances[C] = 0;

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

        if (curDist > distances[cur]) continue;

        for (auto [v, w] : graph[cur]) {
            int nextDist = curDist + w;
            if (nextDist < distances[v]){
                distances[v] = nextDist;
                pq.push({nextDist, v});
            }
        }
    }
}

int main() {
    cin >> N >> M >> C;

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

    solution();

    int connected = 0;
    int maxTime = 0;
    for (int i : distances) {
        if (i != INT_MAX) {
            connected++;
            maxTime = max(i, maxTime);
        }
    }
    cout << connected - 1 << ' ' << maxTime << '\n';

    return 0;
}

[kangrae-jo]

가중치 그래프에서 다익스트라를 구현하는 기본 로직인 것 같네요!
직접 구현해본 것은 처음인데, 나름 직관적으로 이해가 잘 됐습니다.
앞으로는 좀 더 어려운 다익스트라도 마주해보고 싶습니닷. 👍

[g0rnn]

�다익스트라 정말 오랜만이네요. 너무 오래전이라 기억도 안나서 문제를 보자마자 찾아보았습니다. 최단경로를 푸는 문제에서는 거의 신인것 같네요.. 비슷한 유형을 많이 풀어서 빠르게 마스터 해야겠습니다.

어쩌면 정석적인 문제라서 다익스트라 로직은 완전 똑같습니다. 그럼에도 많이 중요한 코드 같으니 전체 코드를 달아두겠습니다.

이번 pr도 수고하셨습니다

code

//
// Created by 김균호 on 2025. 1. 13..
//
#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

int n, m, c;
int s, e, w;
vector<vector<pair<int, int> > > cities;
vector<int> minDist;

void relax(int next, int nDist, priority_queue<pair<int, int> > &pq) {
    if (nDist < minDist[next]) {
        minDist[next] = nDist;
        pq.emplace(-nDist, next);
    }
}

void dijkstra() {
    minDist = vector<int>(n + 1, INT_MAX);
    priority_queue<pair<int, int> > pq;

    minDist[c] = 0;
    pq.emplace(0, c);

    while (!pq.empty()) {
        int dist = -pq.top().first;
        int cur = pq.top().second;
        pq.pop();

        if (minDist[cur] < dist) continue;
        for (auto &city: cities[cur]) {
            int next = city.first;
            int nDist = dist + city.second;
            relax(next, nDist, pq);
        }
    }
}

int main() {
    cin >> n >> m >> c;
    cities.resize(n + 1);
    for (int i = 0; i < m; i++) {
        cin >> s >> e >> w;
        cities[s].emplace_back(e, w);
    }
    dijkstra();
    int cnt = 0;
    int dist = 0;
    for (int &d: minDist) {
        if (d != INT_MAX) {
            cnt++;
            dist = max(dist, d);
        }
    }
    cout << cnt - 1 << ' ' << dist;
    return 0;
}