图论bfs与dfs之网络延迟时间

最新推荐文章于 2022-04-15 18:30:37 发布

原创最新推荐文章于 2022-04-15 18:30:37 发布 · 245 阅读

1 ·

CC 4.0 BY-SA版权

leetcode刷题之旅专栏收录该内容

39 篇文章

订阅专栏

本文详细解析了求解网络延迟时间的问题，通过构建图表并采用BFS和DFS两种方法找到信号传播至所有节点所需的最短时间。适用于了解图算法及信号在网络中的传播问题。

743. 网络延迟时间

难度中等343

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

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

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

示例 1：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2

示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1

示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1

分析

这里还是要进行分析，第一点就是要知道这个结果是什么就是到使得所有的节点都收到信号，同时还要计算好时间，这时候，如果我们维持着used数组，那么只知道这个节点来没来过并不知道上一次来经历了多长时间所以这里我们维持一个vector<int>的数组

其实也就是说，这里面不需要回溯，要的是记录到达某个节点的最小时间

BFS

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
       // 首先构建图表
        map<int,map<int,int>> mp;
        for(auto time : times) {
            mp[time[0]][time[1]]=time[2];
        }
        // 维持一个vector记录到达列表的时间
        vector<int> arrivetime(n,-1);
        arrivetime[k-1]=0;  // 起始点的0

        // bfs部分
        queue<int> que;  // 记录的是起点
        que.push(k);  // 起点

        while(!que.empty()) {
            int sz = que.size();
            for(int i=0;i<sz;i++) {
                int start_point = que.front();
                que.pop();

                // 看看有没有这个起点的路径
                if(mp.count(start_point)) {
                    for(auto& [end_point,costtime] : mp[start_point]) { // 代表着终点以及消耗的时间
                        if(arrivetime[end_point-1]==-1) {
                            arrivetime[end_point-1] = arrivetime[start_point-1]+costtime;
                            que.push(end_point);
                        } else {
                            if(arrivetime[start_point-1]+costtime<arrivetime[end_point-1]) {
                                arrivetime[end_point-1] = arrivetime[start_point-1]+costtime;
                                que.push(end_point);
                            }
                        }

                    }
                }


            }
        }

        // 这时候看arrvitime
        if(find(arrivetime.begin(),arrivetime.end(),-1)!=arrivetime.end()) {
            return -1;
        } 
        // for(auto a : arrivetime) {
        //     cout<<a<<" ";
        // }
        return *max_element(arrivetime.begin(),arrivetime.end());

    }   
};

DFS

class Solution {
public:
    vector<int> arrivetime;
    map<int,map<int,int>> mp;

    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
       // 首先构建图表
        for(auto time : times) {
            mp[time[0]][time[1]]=time[2];
        }
        // 维持一个vector记录到达列表的时间
        vector<int> arr(n,-1);
        arr[k-1]=0;  // 起始点的0
        arrivetime=arr;
       
        dfs(k);
        // 这时候看arrvitime
        // for(auto a : arrivetime) {
        //     cout<<a<<" ";
        // }
        if(find(arrivetime.begin(),arrivetime.end(),-1)!=arrivetime.end()) {
            return -1;
        } 

        return *max_element(arrivetime.begin(),arrivetime.end());

    }   

    // 这里写一下dfs

    void dfs(int startpoint) {
        if(mp.count(startpoint)) {
            for(auto& [endpoint,costtime] : mp[startpoint]) {
                if(arrivetime[endpoint-1]==-1) {
                    arrivetime[endpoint-1]=arrivetime[startpoint-1]+costtime;
                     dfs(endpoint);
                } else {
                    if(arrivetime[startpoint-1]+costtime<arrivetime[endpoint-1]) {
                        arrivetime[endpoint-1]=arrivetime[startpoint-1]+costtime;
                        dfs(endpoint);
                    }
                }
            }
        }
    }

};