【leetcode】图---中等（1）743. 网络延迟时间_BFS（2）785. 判断二分图_BFS（3）*802. 找到最终的安全状态_逆向拓扑_怎么看出网络拓扑中延迟了两个时间槽

743、有 N 个网络节点，标记为 1 到 N。

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

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

示例：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
输出：2

注意:

    N 的范围在 [1, 100] 之间。
    K 的范围在 [1, N] 之间。
    times 的长度在 [1, 6000] 之间。
    所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

 并查集，当t[j] < ei_j + t[i]时，该j点重新入queue，更新与之相邻的点（j可能多次入queue）。

有点类似《挑战程序设计竞赛》Dijkstra使用priority_queue实现的入队思想。书p103

// BFS
// 从k出发，相邻点入队列，同时填写t数组，当t[j] < ei_j + t[i]时，该j点重新入queue，更新与之相邻的点（j可能多次入queue）
typedef pair<int, int> E; // {点，边权}
const int INF = 1e9;
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector<vector<E>> gra(N + 1);
        vector<int> t(N + 1, INF); // 传递到i点要的时间
        for(auto &i:times){
            gra[i[0]].push_back(E(i[1], i[2]));
        }
        queue<int> q;
        q.push(K);
        t[K] = 0;
        int cnt = 1;
        while(!q.empty()){
            int cur = q.front();
            q.pop();
            for(auto &i:gra[cur]){
                if(t[i.first] > t[cur] + i.second) {
                    q.push(i.first);
                    t[i.first] = t[cur] + i.second;
                }
            }
        }
        int ans = -1;
        for(int i = 1; i <= N; i++) {
            if(t[i] == INF) return -1;
            if(ans < t[i]) ans = t[i];
        }
        return ans;
    }
};

结果：

执行用时：164 ms, 在所有 C++ 提交中击败了85.83% 的用户

内存消耗：28.9 MB, 在所有 C++ 提交中击败了20.00% 的用户

 

785、无向图graph，当这个图为二分图时返回true。

如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。

graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边： graph[i] 中不存在i，并且graph[i]中没有重复的值。

示例 1:
输入: [[1,3], [0,2], [1,3], [0,2]]
输出: true
解释: 
无向图如下:
0----1
|    |
|    |
3----2
我们可以将节点分成两组: {0, 2} 和 {1, 3}。

示例 2:
输入: [[1,2,3], [0,2], [0,1,3], [0,2]]
输出: false
解释: 
无向图如下:
0----1
| \  |
|  \ |
3----2
我们不能将节点分割成两个独立的子集。

注意:

    graph 的长度范围为 [1, 100]。
    graph[i] 中的元素的范围为 [0, graph.length - 1]。
    graph[i] 不会包含 i 或者有重复的值。
    图是无向的: 如果j 在 graph[i]里边, 那么 i 也会在 graph[j]里边。

 注意：给定的图中可能有多个联通分支，孤立的点，需要找到每个分支，忽略孤立的点。

BFS，对图进行两种颜色涂色。

// 判断二分图，孤立的点不需判断，可能有多个联通分支
// BFS, 图二色涂色
class Solution {
public:
    bool isBipartite(vector<vector<int>>& graph) {
        vector<int> color(graph.size(), 0);
        queue<int> q;
        for(int i = 0; i < graph.size(); i++){ //找不是孤立的点的联通分支
            if(graph[i].size() > 0 && color[i] == 0){
                q.push(i);
                color[i] = 1;
                while(!q.empty()){
                    int cur = q.front(); q.pop();
                    for(auto &i:graph[cur]){
                        if(color[i] == color[cur]) return false;
                        if(color[i] == 0) {
                            q.push(i);
                            color[i] = -color[cur];
                        }
                    }
                }
            }
        }
        return true;
    }
};

结果：

执行用时：44 ms, 在所有 C++ 提交中击败了92.25% 的用户

内存消耗：11.9 MB, 在所有 C++ 提交中击败了100.00%

 

802、在有向图中, 我们从某个节点和每个转向处开始, 沿着图的有向边走。 如果我们到达的节点是终点 (即它没有连出的有向边), 我们停止。

现在, 如果我们最后能走到终点，那么我们的起始节点是最终安全的。 更具体地说, 存在一个自然数 K,  无论选择从哪里开始行走, 我们走了不到 K 步后必能停止在一个终点。

哪些节点最终是安全的？ 结果返回一个有序的数组。

该有向图有 N 个节点，标签为 0, 1, ..., N-1, 其中 N 是 graph 的节点数.  图以以下的形式给出: graph[i] 是节点 j 的一个列表，满足 (i, j) 是图的一条有向边。

示例：
输入：graph = [[1,2],[2,3],[5],[0],[5],[],[]]
输出：[2,4,5,6]
这里是上图的示意图。

提示：

    graph 节点数不超过 10000.
    图的边数不会超过 32000.
    每个 graph[i] 被排序为不同的整数列表， 在区间 [0, graph.length - 1] 中选取。

安全的点：路径终点，也就是出度为0的点

定义最终安全的点：从起始节点开始，可以沿某个路径到达终点，那么起始节点就是最终安全的点。

 

// 逆向拓扑
// 先找终点，出度为0，逆向删除
class Solution {
public:
    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
        int n = graph.size();
        vector<int> indegree(n);
        vector<vector<int>> gra(n); // 逆向有向图
        for(int i = 0; i < n; i++){
            indegree[i] = graph[i].size();
            for(int j = 0; j < graph[i].size(); j++) gra[graph[i][j]].push_back(i);
        }
        queue<int> q;
        vector<int> ans;
        vector<bool> mark(n, false);
        for(int i = 0; i < n; i++)  if(indegree[i] == 0) {q.push(i); mark[i] = true;}
        while(!q.empty()){
            int cur = q.front();
            q.pop();
            ans.push_back(cur);
            for(auto &i:gra[cur]){
                indegree[i]--;
                if(indegree[i] == 0 && !mark[i]) {q.push(i); mark[i] = true;}
            }
        }
        sort(ans.begin(), ans.end());
        return ans;
    }
};

结果：

执行用时：356 ms, 在所有 C++ 提交中击败了53.54% 的用户

内存消耗：49.3 MB, 在所有 C++ 提交中击败了100.00% 的用户