Dijkstra求最单源短路径

1.思想

迪杰斯特拉是一种贪心的思想，每次都找距离单源最短的，然后不断更新就可以得到每个点的最短距离。

2.算法描述

1. 循环n次数
2. 每次找不在集合vis中的，距离源头最短的点u
3. 找到后更新不在集合中的所有点的距离。
   更新操作为: 如果dis[v] = min(dis[u] + G[u][v]), G[u][v]保存(u,v)的距离。

2. 三种实现

1. 采用邻接矩阵存储图

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

/**
 * 
 * 求单源最短路径
 * 1. 加入最近的点
 * 2. 更新每个点的距离
 * 3. 直到所有的点都被加入进来为止
 * 
 * 
 * 有重边和自环，所以需要保存最小值。
*/

const int MAXN = 510;
const int INF = 0x3f3f3f3f;
int G[MAXN][MAXN];
int n, m;
int d[MAXN];
int s[MAXN];

int djstra() {
    for (int i = 0; i < n; i ++) {  
        int t = -1;
        for (int j = 1; j <= n; j++) {              // 从没有加入的点中找到最小距离的点
            if (!s[t] && (t == -1 || dis[t] > dis[j])) {
                t = j;
            } 
        }
        s[t] = 1;                                   // 加入集合中，并且记录最小的距离
        if (j = 1; j <= n; j++) {                   // 跟新所有不在集合s中，并且有边的点
            if (!s[j])
                d[j] = minv(minv + G[t][j], d[j]); 
        }
    }
    return d[n] >= INF ? -1 : d[n]; 
}

int main() {
    cin >> n >> m;
    memset(G, 0x3f, sizeof G);
    memset(d, 0x3f, sizeof(d));
    d[1] = 0;
    for (int i = 0; i < m; i ++) {
        int a, b, c;
        cin >> a >> b >> c;
        G[a][b] = G[b][a] = min(G[a][b], c);
    }
    printf("%d\n", djstra());
    return 0;
}

2.使用优先队列进行优化

class Solution {
public:
    struct HeapNode{
        int d, u;
        bool operator < (const HeapNode &rhs) const {
            return d > rhs.d;
        }
    };
    struct Edge {
        int from, to, dist;
        Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
    };
    int INF = 0x3f3f3f3f;
    typedef pair<int, int>PR;
    vector<Edge> edges;
    vector<vector<int>>G;
    vector<int>vis;
    vector<int>dis;
    int n, m;
    int dijkstra(int s) {
        int ans = 0;
        priority_queue<HeapNode>que;
        dis[s] = 0;
        que.push((HeapNode){0, s});
        while(!que.empty()) {
            auto [dist, u] = que.top(); que.pop();
            if (vis[u]) continue;
            vis[u] = 1;
            // printf("u = %d m = %d dis = %d\n", u, G[u].size(), dis[u]);
            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (dis[e.to] > dis[u] + e.dist) {
                    dis[e.to] = dis[u] + e.dist;
                    que.push((HeapNode){dis[e.to], e.to});
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            ans = max(ans, dis[i]);
        }
        return ans >= INF ? -1 : ans;
    }
    void addEdge(int from, int to, int dist) {
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        this->n = n;
        G = vector<vector<int>>(n + 1);
        vis = vector<int>(n + 1, 0);
        dis = vector<int>(n + 1, INF);
        for (auto &vec: times) {
            addEdge(vec[0], vec[1], vec[2]);
        }
        return dijkstra(k);      
    }
};

3. 暴力循环法

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        vector<int>d(n + 1, INT_MAX);
        d[k] = 0;
        while(1) {
            bool update = false;
            for(auto edge: times) {
                int from  = edge[0];
                int to = edge[1];
                int cost = edge[2];
                if(d[from] != INT_MAX && d[from] + cost < d[to]) {
                    d[to] = d[from] + cost;
                    update = true;
                }
            }
            if(!update) break;
        }
     
        int ans = 0;
        for(int i = 1; i <= n; i++) {
            ans = max(ans, d[i]);
        }
        return ans == INT_MAX ? -1 : ans;
    }
};