【算法笔记】最短路径——单源最短路径，Dijsktra算法（贪心算法）

适用条件

• 有向图 or 无向图
• 非负权（所有边权都 $⩾$ 0 ）
• 单源最短路径（给定源点s，求s到其他顶点的最短路径）

使用到的数据结构

• 集合S：记录所有已经找到最短路径的节点
  • 初始时S中只有一个节点 S={s}
  • 迭代结束时S为所有源点s可以到达的节点的集合
    • 此时如果目标节点t不在集合S中，就认为从源点s无法到达t
  • 每一轮迭代选出一个新的节点加入集合S中，即每一次迭代都能为一个新的节点找到最短路径
• 数组dist：dist[p] 是目前为止能够从集合S到达节点p的最短距离
  • dist数组的长度等于图中的节点数n，即每一个节点i都有一个对应的dist[i]值，因此理论上来讲需要迭代n次，为每一个节点都找到最短路径
  • 在每一轮迭代中，从所有尚未找到最短路径的节点（不在集合S中的节点）中选出dist值最小的一个，加入集合S，并根据选出的节点更新dist数组的内容
  • 如果在某一轮迭代时，剩余节点的dist值都是INF，说明剩余节点都是不可达的，此时可以直接终止循环迭代的过程
  • 当算法迭代完之后，dist[i]即为从源点s到节点i的最短路径的长度
  • 初始化：
    • dist[s] = 0: s到自身的距离为0
    • dist[i] = edge[s][i]：对于能够从源点s直达的节点i，dist[i]等于直达边的权重
    • dist[else] = INF
• 数组path：path[i]记录「与dist[i]对应的路径（一条从s到i的路径）」的倒数第二个节点（即节点i的上一个节点），用于回溯最短路径
  • 初始化：
    • path[s] = -1 （路径回溯终止标志）
    • path[源点s的直达节点] = s
  • 如果在算法迭代完之后想要获取到达节点i的最短路径：
    • 最短路径的最后一个节点为last_1 = i
    • 最短路径的倒数第二个节点为last_2 = path[last_1] = path[i]
    • 最短路径的倒数第三个节点为last_3 = path[last_2]
    • …
    • 如果遇到某一个节点，其对应的path值为-1，即回溯到了源点s，此时整条最短路径已经获得，可以终止回溯过程

例子

SEUOJ_1028

• 无向图
• 可能有重复边，因为是求最短路径，所以只需要保存两点之间权值最小的边即可
• 节点编号从1开始

#include <iostream>
#include <stdio.h>
#include <climits>
#include <iomanip>
#include <set>
#include <queue>
using namespace std;

const int MAXN = 500, MAXE = 10000;
const int INF = INT_MAX;

int n, E, s, t; 
int edges[MAXN+1][MAXN+1]; // edges[u][v] == INF: u与v之间无边 

void print_test_input(){
    cout << "edges:" << endl;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++){
            if(edges[i][j] != INF)
                cout << setw(5) << edges[i][j];
            else 
                cout << setw(5) << "INF";
        }
        cout << endl;
    }
}

void input(){
    cin >> n >> E >> s >> t;
    // 重置edges数组
    for(int i=0; i<=n; i++){
        for(int j=0; j<=n; j++){
            edges[i][j] = INF;
        }
    }
    
    // 读图   
    int u, v, w;
    for(int i=0; i<E; i++){
        cin >> u >> v >> w;
        // edges[u][v] = min(edges[u][v], w); // 有向图
        edges[u][v] = edges[v][u]= min(edges[u][v], w); // 无向图
    }
}

set<int> S;
int dist[MAXN+1];
int path[MAXN+1];

void print_test_dijkstra(){
    cout << "S:";
    for(set<int>::iterator it=S.begin(); it!=S.end(); it++) 
        cout <<  *it << " ";
    cout << endl;

    cout << "dist:";
    for(int i=1; i<=n; i++){
        if(dist[i] == INF) cout << "INF ";
        else cout << dist[i] << " ";
    }
    cout << endl;
}

void dijkstra(){
    // 初始化
    S.clear();
    S.insert(s);

    for(int i=1; i<=n; i++){
        dist[i] = INF;
    }
    dist[s] = 0;
    path[s] = -1;
    for(int i=1; i<=n; i++){
        if(edges[s][i] != INF){
            dist[i] = edges[s][i];
            path[i] = s;
        }
    }

    // print_test_dijkstra();

    // 迭代n-1次，为除S外每一个节点都找到最短路径
    for(int i=1; i<n; i++){
        // 从所有尚未找到最短路径的节点（不在集合S中的节点）中选出dist值最小的一个
        int min_dist = INF, min_dist_p = -1;
        for(int j=1; j<=n; j++){
            if(S.find(j)==S.end() && dist[j] < min_dist){
                min_dist = dist[j];
                min_dist_p = j;
            }
        }
        // 将min_dist_p加入S中
        S.insert(min_dist_p);
        // 根据min_dist_p更新dist中的内容准备进行下一轮迭代
        for(int j=1; j<=n; j++){
            if( S.find(j) == S.end()
            && edges[min_dist_p][j] != INF
            && min_dist+edges[min_dist_p][j] < dist[j]){
                dist[j] = min_dist+edges[min_dist_p][j];
                path[j] = min_dist_p;
             }
        }
        // print_test_dijkstra();
    }
}

queue<int> min_path;

bool print_min_path(int t){
    if(dist[t] == INF){
        return false;
    }
    
    min_path.push(t);
    while(path[t] != -1){
        min_path.push(path[t]);
        t = path[t];
    }
    cout << "min path: ";
    while(!min_path.empty()){
        cout << min_path.back() << " ";
        min_path.pop();
    }
    cout << endl;
    return true;
}

int main(){
    // freopen("test.txt", "r", stdin);

    int T;
    cin >> T;
    for(int i=0; i<T; i++){
        input();
        // print_test_input();
        dijkstra();
        if(dist[t] != INF){
            cout << dist[t] << endl;
        }else{
            cout << -1 << endl;
        }
        // print_min_path(t);
    }

    return 0;
}