【leetcode】图---中等（1）133. 克隆图_dfs/map（2）207. 课程表_queue拓扑排序（3）210. 课程表 II_拓扑排序+返回拓扑序列（4）*310. 最小高度树_拓扑

133、给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。

图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
    public int val;
    public List<Node> neighbors;
}

测试用例格式：

简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

示例 1：

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

 dfs，遇到点new一下，保存val值，用dfs找neighbors。Attention：用一个unordered_map映射val和该节点指针node*，便于dfs时判断结束条件。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<int, Node*> mark;
    vector<Node*> dfs(Node* x, Node* old){
        vector<Node*> vec;
        for(auto &it:old->neighbors){ // 每一个it是一个Node*
            if(mark.count(it->val)) {
                vec.push_back(mark[it->val]);
                continue;
            }
            Node* next = new Node(it->val);
            mark[next->val] = next;
            next->neighbors = dfs(next, it);
            vec.push_back(next);
        }
        return vec;
    }

    Node* cloneGraph(Node* node) {
        if(node == nullptr) return {};
        Node* root = new Node(node->val);
        mark[root->val] = root;
        root->neighbors = dfs(root, node);
        return root;
    }
};

结果：

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

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

 

拓扑排序

207、你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]

给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？

示例 1:

输入: 2, [[1,0]] 
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。

示例 2:

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

 队列，实现拓扑排序。

// 拓扑排序
class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& pre) {
        vector<int> indegree(numCourses, 0);    // 存每个点的入度，每次找入度为0的点删除。
        vector<vector<int>> gra(numCourses);
        queue<int> q;
        for(auto &i:pre){
            indegree[i[1]]++;
            gra[i[0]].push_back(i[1]);
        }
        int cnt = 0;
        while(!q.empty()) q.pop();
        for(int i = 0; i < numCourses; i++) if(indegree[i] == 0) q.push(i);
        while(!q.empty()){
            int t = q.front();
            q.pop();
            cnt++;
            for(auto &i:gra[t]) {
                indegree[i]--;  //  删除t点，并删除从t发出的边==>与之相邻点的入度减一
                if(indegree[i] == 0) q.push(i);
            }       
        }
        if(cnt < numCourses) return false;
        else return true;
    }
};

结果：

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

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

 

拓扑序列

210、现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

示例 1:

输入: 2, [[1,0]] 
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

示例 2:

输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
     因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

 拓扑排序，返回拓扑序列

// 拓扑排序，返回拓扑序列
class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> gra(numCourses);    // 邻接链表存图
        vector<int> indgree(numCourses, 0);     // 存每个点的入度，每次选indgree=0的点删除
        vector<int> ans;    // 存拓扑序列
        queue<int> q;
        for(auto &i:prerequisites){ //  [a,b] b-->a
            indgree[i[0]]++;
            gra[i[1]].push_back(i[0]);
        }
        while(!q.empty()) q.pop();
        for(int i = 0; i < numCourses; i++) if(indgree[i] == 0) q.push(i);
        int cnt = 0;
        while(!q.empty()){
            int t = q.front();
            q.pop(); 
            ans.push_back(t);
            cnt++;
            for(auto &i:gra[t]) {
                indgree[i]--;
                if(indgree[i] == 0) q.push(i);
            }
        }
        if(cnt < numCourses) ans.clear();
        return ans;
    }
};

结果：

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

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

 

310、对于一个具有树特征的无向图，我们可选择任何一个节点作为根。图因此可以成为树，在所有可能的树中，具有最小高度的树被称为最小高度树。给出这样的一个图，写出一个函数找到所有的最小高度树并返回他们的根节点。

格式

该图包含 n 个节点，标记为 0 到 n - 1。给定数字 n 和一个无向边 edges 列表（每一个边都是一对标签）。

你可以假设没有重复的边会出现在 edges 中。由于所有的边都是无向边， [0, 1]和 [1, 0] 是相同的，因此不会同时出现在 edges 里。

示例 1:

输入: n = 4, edges = [[1, 0], [1, 2], [1, 3]]

        0
        |
        1
       / \
      2   3 

输出: [1]

示例 2:

输入: n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]

     0  1  2
      \ | /
        3
        |
        4
        |
        5 

输出: [3, 4]

每个节点BFS查其树高，选最小树高的节点，即为答案。但导致超时61 / 66 个通过测试用例。n=1919时，开始超时：

// 每个点BFS 
const int INF = 1e9;
class Solution {
public:
    vector<vector<int>> gra;
    int BFS(int r, int n){
        queue<int> q;
        q.push(r);
        vector<int> height(n, -1);
        height[r] = 0;
        int cnt = 1, h = 0;
        while(cnt < n){
            int t = q.front();
            q.pop();
            for(auto &i:gra[t]){
                if(height[i] == -1){
                   q.push(i);
                   height[i] = height[t] + 1;
                   cnt++;
                   h = max(h, height[i]);
                }
            }
        }
        return h;
    }

    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        gra.resize(n);
        for(auto &i:edges){ //  图初始化
            gra[i[0]].push_back(i[1]);
            gra[i[1]].push_back(i[0]);
        }
        vector<int> ans;
        int minH = INF;
        for(int i = 0; i < n; i++){ //  每个点BFS
            int h = BFS(i, n);
            if(minH > h){
                minH = h;
                ans.clear();
                ans.push_back(i);
            }else if(minH == h) ans.push_back(i);
        }
        return ans;
    }
};

修改：

利用拓扑排序，找最内部的节点。每次删除度为1的点，存储每个点的高度h，最外层h=0，每往里走一次h+1，目标点为具有最大h的点集合。

// 找最内部的点，作为root
class Solution{
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        vector<int> degree(n, 0);
        vector<vector<int>> gra(n);
        for(auto &i:edges){
            degree[i[0]]++;
            degree[i[1]]++;
            gra[i[0]].push_back(i[1]);
            gra[i[1]].push_back(i[0]);
        }
        queue<int> q;
        vector<int> h(n, 0);
        for(int i = 0; i < n; i++) if(degree[i] == 1) q.push(i);
        while(!q.empty()){
            int t = q.front();
            q.pop();
            for(auto &i:gra[t]){
                degree[i]--;
                if(degree[i] == 1) {
                    q.push(i);
                    h[i] = h[t] + 1;
                }
            }
        }
        int maxH = -1;
        vector<int> ans;
        for(int i = 0; i < n; i++){
            if(maxH < h[i]){
                maxH = h[i];
                ans.clear();
                ans.push_back(i);
            }else if(maxH == h[i]) ans.push_back(i);
        } 
        return ans;
    }
};

结果：

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

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