2-wnsmir

[wnsmir]

🔗 문제 링크

https://www.acmicpc.net/problem/1916

✔️ 소요된 시간

25m

✨ 수도 코드

최소비용문제를 보자마자 지난학기 알고리즘시간에 배운
다익스트라, 벨만포드, 플로이드와샬 알고리즘중
어떤 알고리즘을 사용해야할지 고민되었습니다.

세가지 알고리즘의 시간복잡도는 순서대로 O(E \log V), O(VE), O(V^3)인데
음수가중치가 없기때문에 벨만포드는 제외할 수 있었고, 시작과 끝점이 정해져 모든 쌍을 알 필요는 없었기에 다익스트라 알고리즘을 사용하면 최적의 문제풀이법이겠다 싶었습니다.

1. graph에 모든 간선data 저장
2. 출발점에서 각 노드까지의 거리 배열에 저장 및 초기화
3. 우선순위큐 사용 (비용, 노드)형식으로 push => 비용이 작은것부터, 큰것은 무시
4. 큐에 튜플이 존재한다면, 비용이 가장적은 노드에서 인접노드까지의 거리 더한 후 distance값 갱신
5. 큐가 빌때까지 반복

📚 새롭게 알게된 내용

큐에 튜플형식으로 저장하면 최소힙은 튜플의 첫번째 원소값을 기준으로 정렬된다는것을 알게되었습니다.
힙을 이용한 다익스트라 알고리즘의시간복잡도가 O(E \log V)인 이유는 먼저 힙의 시간복잡도가 O(E \log V)이고 최대를 가정헸을때 O(E \log V),
이를 모든 간선의 수 E만큼 반복하기 때문에 간선수에 더 큰 영향을 받으므로 최종적으로 O(E \log V)가 됩니다.

[kangrae-jo]

다익스트라 알고리즘은 그렇다치고 그래프를 활용한 알고리즘 문제도 오랜만이네요.
좋은 문제 소개 감사합니다. 전 이거 어렵던데 엄청 빨리 푸셨네요..

그런데 뭔가 문제와 풀이에 추가 설명이 좀 더 있으면 좋을 것 같아서 조금 남겨보겠습니다.

이 문제는 음수 가중치가 없는 방향 그래프를 사용히여 생각할 수 있습니다.
(출발하는 도시를 진출간선이 있는 노드, 도착하는 노드를 진입간선이 있는 노드, 간선의 가중치는 버스비)

그래프를 구현하는 방식에는 2가지가 있습니다. (제가 배우기로는 2가지)

1. 인접 리스트
2. 인접 행렬
   (혹시 저처럼 가물가물하신 분들은 다시 찾아보시길 바랍니다.)

다익스트라 구현에서는 현재 노드의 진출간선을 다 따져 봐야하는 부분이 있고,
모든 노드가 연결되어있지 않기때문에 인접 리스트가 더욱 효율 적입니다.

그래프가 구현되고나서는 전형적인 다익스트라 알고리즘으로 구현됩니다.
다익스트라 알고리즘은 많은 설명이 필요하니 사진으로 대체합니다.

(사진 출처는 권오흠 교수님 알고리즘 강의자료입니다. 혹시 문제되진않겠죠..?)

우선순위 큐를 사용하는데 이것의 기본 셋팅은 최대 힙입니다.
C++에서는 최대 힙이고 다른 언어는 모르겠습니다.

그래서 우선순위 큐 생성 시에 first항목에 버스 비용을 넣고 greater 조건을 넣어서 first항목에 대한 최소힙으로 바꿔준다면...
버스 비용이 적은 순서로 정렬이 됩니다.

이 정도가 이번 문제에서 알아야하는 핵심인 듯 합니다.

고생하셨습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <limits.h>

using namespace std;

int dijkstra(vector<vector<pair<int, int> > >& graph,int start, int end) {
    int N = graph.size();

    vector<int> dist(N, INT_MAX);
    priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > pq;

    dist[start] = 0;
    pq.push(make_pair(0, start));

    while (!pq.empty()) {
        int currentCost = pq.top().first;
        int currentNode = pq.top().second;
        pq.pop();

        if (currentCost > dist[currentNode]) continue;

        for (auto next : graph[currentNode]) {
            int next_node = next.first;
            int next_cost = next.second;

            if (dist[next_node] > dist[currentNode] + next_cost) {
                dist[next_node] = dist[currentNode] + next_cost;
                pq.push(make_pair(dist[next_node], next_node));
            }
        }
    }
    return dist[end];
}

int main() {
    // 1) input
    int N, M;
    cin >> N >> M;

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

    int start, end;
    cin >> start >> end;
    
    // 2) solution
    cout << dijkstra(graph, start, end) << "\n";

    return 0;
}

[kangrae-jo]

덕분에 까맣게 잊고있었던 다익스트라 알고리즘을 다시 공부했습니다.
문제를 풀면서 준용님의 파이썬 코드를 참고했습니다.
개념을 다시 학습하면서 문제를 푸니 1시간이 넘어갔네요.

전형적인 다익스트라 알고리즘이라 언어가 달라도 형태는 비슷하네요.

이 문제를 풀 때 그래프 구현을 인접리스트로 하는 것이 인접 배열보다 2가지 측면에서 좋다고 생각합니다.

1. 메모리 공간 절약
2. 이어진 모든 노드 탐색 시간 절약

준용님의 풀이에서 그래프도 인접 리스트로 잘 구현된 것 같네요. 좋습니닷.

쓸데없는 말이지만 c++에서는 make_pair로 묶어줘야 push가 가능한데 파이썬은 그냥 괄호로 묶는거 부럽습니다.

[wnsmir]

인접행렬보단 인접리스트가 시간복잡도면에서 간선이 많을수록 유리하다 생각하여 인접리스트를 사용했습니다.

다만 이생각이 너무 굳어져 그래프라면 인접행렬로도 풀 수 있는데 인접리스트로만 너무 당연하게 생각했던것 같아 뒤돌아보게 되는 코멘트였습니다!

[g0rnn]

저도 풀어봤씁니당. 잊었던 다익스트라를 공부할 수 있는 좋은 문제였습니다

code

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

int n, m;
vector<vector<pair<int, int>>> graph; // pair = { node, dist }

int dijkstra(int src, int dst) {
	vector<int> dist(n+1, INT_MAX);

	// pair = { dist, node } -> 최대 힙의 기준은 pair의 첫번째 요소가 됨
	priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

	dist[src] = 0;
	pq.push({0, src});

	while (!pq.empty()) {
		int cur_node = pq.top().second;
		int cur_dist = pq.top().first;
		pq.pop();

		//이미 최적화된 노드를 방문하게 될 때
		if (cur_dist > dist[cur_node]) continue;

		for (auto adj : graph[cur_node]) {
			int nxt_node = adj.first;
			int nxt_dist = adj.second;

			if (dist[nxt_node] > dist[cur_node] + nxt_dist) {
				dist[nxt_node] = dist[cur_node] + nxt_dist;
				pq.push({dist[nxt_node], nxt_node});
			}
		}
	}
	return dist[dst];
}

int main() {
	cin >> n >> m;

	int src, dst, dist;
	graph.resize(n+1);

	for (int i = 0; i < m; i++) {
		cin >> src >> dst >> dist;
		graph[src].push_back(make_pair(dst, dist));
	}

	cin >> src >> dst;
	
	cout<< dijkstra(src, dst);
	return 0;
}

[kokeunho]

알고리즘 처음 공부하는 입장이라 모든 PR에 공부가 꽤 필요하네요...
덕분에 최소비용문제에 사용하는 알고리즘과 가중치가 있는 최단 거리문제에 노드의 수가 많은 경우, 힙을 사용한 다익스트라 알고리즘이 효율적이라는 것을 배울 수 있었습니다.
최단 거리를 계속 갱신하는 코드는 조금 이해가 어려웠습니다만, 어느 정도 이해를 했습니다. 추후에 비슷한 알고리즘 풀어보겠습니다.
수고하셨습니다!