Dijkstra（力扣743）和bellman-Ford（力扣1514）

路由算法

1.dijkstra

普通实现时间复杂度$O(N^2)$，堆实现时间复杂度$O(NlogN)$

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        int book[n+1];
        int map[n+1][n+1];
        int dis[n+1];
        memset(book, 0, sizeof(book));//0代表当前没有加入路径
        //memset(map, -1, sizeof(map));//-1代表不可达
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                map[i][j] = 999999;
            }
        }
        for(int i = 0; i < times.size(); i++){
            map[times[i][0]][times[i][1]]=times[i][2];
        }
        map[k][k] = 0;
        for(int i = 1; i <= n; i++){
            dis[i] = map[k][i];
        }
        book[k] = 1;
        for(int i = 0; i < n-1; i++){
            int mindis = 999999;
            int cur = 0;
            for(int j = 1; j <= n; j++){
                if(!book[j] && dis[j] != -1 && dis[j] < mindis){
                    mindis = dis[j];
                    cur = j;
                }
            }
            if(cur == 0){
                return -1;
            }
            book[cur] = 1;
            
            for(int q = 1; q <= n; q++){
                if(!book[q] && (dis[cur] + map[cur][q]) < dis[q]){
                    dis[q] = dis[cur] + map[cur][q];
                }
            }
        }
        int maxdis = INT_MIN;
        for(int i = 1; i <= n; i++){
            //cout << dis[i] <<endl;
            maxdis = max(maxdis, dis[i]);
        }
        return maxdis == 999999? -1:maxdis;
    }
};

2.bellman-ford

普通实现时间复杂度$O(|V||E|)$，V是节点个数，E是边数

class Solution {
public:
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
        double dis[n];
        //不能创建一个map,太大了超界
        for(int i = 0; i < n; i++){
            dis[i] = 0;
        }
        dis[start] = 1;
        for(int i = 0; i < n-1; i++){
            bool flag = false;
            for(int j = 0; j < edges.size(); j++){
                int u = edges[j][0];
                int v = edges[j][1];
                if(dis[v] < dis[u] * succProb[j]){
                    dis[v] = dis[u] * succProb[j];
                    flag = true;
                }
                if(dis[u] < dis[v] * succProb[j]){
                    dis[u] = dis[v] * succProb[j];
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
        
        return dis[end];
    }
};