最短路（一）Dijkstra(743.网络延迟时间)

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

思想

1.一般求单源最短路
2.用的贪心
3.用已经确定是最短路径的结点去更新其他路径
4.带权图
5.需要dist（记录i到每个结点的最短路组），used（该节点是否已被确定为最短路）

---

一、例子

模拟过程
利用Dijkstra算法求出从源点1到其它各顶点的最短路径

二、代码

1.以leetcode743为例

有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi
是目标节点， wi 是一个信号从源节点传递到目标节点的时间。

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

来源：力扣（LeetCode）
链接：743.网络延迟时间
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码如下（邻接矩阵）：

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        int inf=0x3ffffff,ans=0;
        //邻接矩阵
        vector<vector<int>>g(n,vector<int>(n,inf));
        vector<int>used(n,0);
        vector<int>dist(n,inf);
        for(auto& t:times)
        {
            int x=t[0]-1;
            int y=t[1]-1;
            g[x][y]=t[2];
        }
        dist[k-1]=0;
        for(int i=0;i<n;i++)
        {
            int x=-1;
            // 在还未确定最短路的点中，寻找距离最小的点
            for(int j=0;j<n;j++)
            {
                if(!used[j]&&(x==-1||dist[x]>dist[j]))//第一个要特殊处理
                {
                    x=j;
                }
            }
            used[x]=1;
            // 用该点更新所有其他点的距离
            for(int j=0;j<n;j++)
            {
                dist[j]=min(dist[j],dist[x]+g[x][j]);
            }
        }
        for(int i=0;i<n;i++)
        {
            ans=max(dist[i],ans);
        }
        if(ans==inf)return -1;//未找到
        return ans;
    }
};

2.堆优化

代码如下（示例）：

class Solution {
public:
    vector<unordered_map<int,int>>mp;
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        int inf=0x3ffffff,ans=-1;
        // 建图 - 邻接表
        mp.resize(n );
        //vector<int>used(n,0);
        vector<int>dist(n,inf);
        for(auto& t:times)
        {
            int x=t[0]-1;
            int y=t[1]-1;
            mp[x][y]=t[2];
        }
        //dist[k-1]=0;
        // 优先队列中存放 (收到信号时间，结点)
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> s;
        s.emplace(pair(0, k-1));
        while(!s.empty())
        {
            // 在还未确定最短路的点中，寻找距离最小的点
            auto cur=s.top();
            s.pop();
            if(dist[cur.second]!=inf)continue;//保证确定的最短路的点不被更改，
            dist[cur.second]=cur.first;
            
            // 用该点更新所有其他点的距离
            for(auto& edg:mp[cur.second])
            {
                if(dist[edg.first]==inf)
                {
                    s.emplace(pair(edg.second + cur.first, edg.first));
                }
            }
        }
        for(int i=0;i<n;i++)
        {
            ans=max(dist[i],ans);
        }
        if(ans==inf)return -1;//未找到
        return ans;
    }
};

解释：
比如1->3->2=19,1->2=20（前面的图）
先将1->2=20放入队列
因为1->3一定小于20，则一定先更新3，
通过3将（19，2）放入队列
因为2更新了，dist不是inf了，所以即使下次遇到（20，2）
也会直接continue

if(dist[cur.second]!=inf)continue;

 s.emplace(pair(edg.second + cur.first, edg.first));

---

总结

复杂度分析：
1.O(n^2+m) n,m 分别为节点和边的数量
O(n^2)
无法处理负边权的图
2.O(ElogE)
O(N+E)