用邻接矩阵的Dijkstra求最短路径算法

用邻接矩阵的Dijkstra求最短路径算法

1.变量定义

int g[N][N];    // 因为dijkstra算法通常用于求稠密图，所以选择用邻接矩阵来存储
int dist[N];    // 用来存储每个节点到源点的距离
int state[N];   // 用来记录该点的最短距离是否已经确定

2.初始化，需要结合后面的代码来看

    memset(dist, INF, sizeof dist);    // 初始化距离，0x3f表示为无穷大
    dist[1] = 0;

3.判断逻辑

memset(dist, INF, sizeof dist); 
dist[1] = 0;	// 源点1到其本身的距离为0，作为初始化值
for(int i = 0; i < n; i++) {
    int t = -1;
    // 遍历dist数组，找到没有确定最短路径节点中的距离源点最近的t
    for(int j = 1; j <= n; j++) {
        if(!state[j] && (t == -1 || dist[j] < dist[t])) {
            t = j;
        }
    }
    state[t] = 1;
}

需要注意的是，这个判断循环中定义了一个变量t，其作用可以理解为记录用于比较的上一个点，初始赋值为-1是为了直接跳过第-1个点（无意义点）和第1个点的判断比较。
那么有人会问，为什么不直接将t赋值为第1个点然后与第2个点比较作为开始呢？我们考察一下当初始值t = 1，j = 2时的情况：

memset(dist, INF, sizeof dist); 
dist[1] = 0;	// 源点1到其本身的距离为0，作为初始化值
for(int i = 0; i < n; i++) {
    int t = 1;
    // 遍历dist数组，找到没有确定最短路径节点中的距离源点最近的t
    for(int j = 2; j <= n; j++) {
        if(!state[j] && (t == -1 || dist[j] < dist[t])) {
            t = j;
        }
    }
    state[t] = 1;
}

这时会存在一个问题：因为dist[1] = 0，而每次对state[j]的判断都是从2开始，所以dist[1]会永远小于任何dist[j]，那么t永远都不会更新。

● 优化：考虑一下t = 0的情况，参考自849. Dijkstra求最短路 I - AcWing题库

dist[1] = 0;	// 源点1到其本身的距离为0，作为初始化值
for(int i = 0; i < n; i++) {
    int t = 0;
    // 遍历dist数组，找到没有确定最短路径节点中的距离源点最近的t
    for(int j = 1; j <= n; j++) {
        if(!state[j] && dist[j] < dist[t]) {
            t = j;
        }
    }
    state[t] = 1;
}

dist[0]在memset的时候也一起被初始化为了无穷大，所以必定是满足dist[0] <= dist[j]，t必定可以更新，由此可以省去写t == -1的判断部分。

4.更新逻辑

for(int j = 1; j <= n; j++){    //依次更新每个点到相邻的点路径值
    dist[j] = min(dist[j], dist[t] + g[t][j]);
}

这个需要注意的地方是，最最最开始的时候，g[N] [N]和dist[N]全都是INF无穷大，只有当经历了外层循环i = 1时，更新逻辑才会将整个图进行真正意义上的初始化，而i = 1时，也可以理解为是对state[1] = 1源点本身状态的初始化。

5.完整代码

#include <bits/stdc++.h>

using namespace std;

const int N = 510;
const int INF = 0x3f3f3f3f;

int n, m;
int g[N][N];    // 因为dijkstra算法通常用于求稠密图，所以选择用邻接矩阵来存储
int dist[N];    // 用来存储每个节点到源点的距离
int state[N];   // 用来记录该点的最短距离是否已经确定

int Dijkstra(){
    memset(dist, INF, sizeof dist);    // 初始化距离，0x3f表示为无穷大

    dist[1] = 0;

    for(int i = 0; i < n; i++){ // 因为一共有n个节点，所以要进行n次递归
        int t = 0;

        for(int j = 1; j <= n; j++){    // 遍历dist数组，找到没有确定最短路径节点中的距离源点最近的t
            if(!state[j] && dist[t] > dist[j])
                t = j; 
        }

        state[t] = 1;

        for(int j = 1; j <= n; j++){    //依次更新每个点到相邻的点路径值
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        }
    }

    if(dist[n] == INF)   //如果第n个点路径为无穷大即不存在最低路径
        return -1;
    return dist[n];
}

int main(){
    cin >> n >> m;
    memset(g, INF, sizeof g);
    for(int i = 0; i < m; i++){
        int x, y, z;
        cin >> x >> y >> z;
        g[x][y] = min(g[x][y], z);
    }

    cout << Dijkstra() << endl;
    return 0;
}