最短路（二）SPFA&Floyed (743.网络延迟时间)

最新推荐文章于 2024-08-10 17:00:48 发布

一个田螺突然就

最新推荐文章于 2024-08-10 17:00:48 发布

阅读量378

点赞数

分类专栏： leetcode 文章标签：图论算法 c++ leetcode

本文链接：https://blog.csdn.net/qq_39964641/article/details/122767085

版权

leetcode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

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

SPFA&Floyed

题目
一、SPFA
二、Floyed
总结

题目

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

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

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

Dijkstra题解
存个代码

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

一、SPFA

代码如下（示例）：

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),cnt(n,0);
        // 记录结点最早收到信号的时间
        for(auto& t:times)
        {
            int x=t[0]-1;
            int y=t[1]-1;
            mp[x][y]=t[2];
        }
        dist[k-1]=0;
        queue<int> que;
        que.push(k-1);
        used[k-1]=1,cnt[k-1]++;

        while(!que.empty())
        {
           
            auto cur=que.front();
            que.pop();
           used[cur]=0;
            
            // 用该点更新所有其他点的距离
            for(auto& edg:mp[cur])
            {
                if (dist[edg.first] > dist[cur] + edg.second) 
                {
                    dist[edg.first] = dist[cur] + edg.second;
                    if (!used[edg.first]) 
                    {
                        que.push(edg.first);
                        used[edg.first]=1;
                        cnt[edg.first]++;
                        if(cnt[edg.first]>n)return -1;//负环
                    }
                }
            }
        }
        for(int i=0;i<n;i++)
        {
            ans=max(dist[i],ans);
        }
        if(ans==inf)return -1;//未找到
        return ans;
    }
};

二、Floyed

代码如下（示例）：

class Solution {
public:
    
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        int inf=0x3ffffff,ans=-1;
        // 建图 - 邻接矩阵
        vector<vector<int>>mp(n,vector<int>(n + 1, inf));
        //vector<int>used(n,0);//是否在队列
        vector<int>dist(n,inf);
        // 记录结点最早收到信号的时间
        for (int i = 0; i < n; i++)
            mp[i][i] = 0;
        for(auto& t:times)
        {
            int x=t[0]-1;
            int y=t[1]-1;
            mp[x][y]=t[2];
        }
        
        
        for (int s = 0; s < n; s++) 
        {
            for (int i = 0; i < n; i++) 
            {
                for (int j = 0; j < n; j++) 
                {
                    mp[i][j] = min(mp[i][j], mp[i][s] + mp[s][j]);
                }
            }
        }

        for(int i=0;i<n;i++)
        {
            ans=max(mp[k-1][i],ans);
        }
        if(ans==inf)return -1;//未找到
        return ans;
    }
};