图论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);
                    }
                }
            }
        }
    }

};