22考研DS（2021-06-12)

22考研DS（2021-06-12）

1.力扣133. 克隆图

题目：

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

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

class Node {
public int val;
public List 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 。

示例 2：

输入：adjList = [[]]
输出：[[]]
解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。

示例 3：

输入：adjList = []
输出：[]
解释：这个图是空的，它不含任何节点。

示例 4：

输入：adjList = [[2],[1]]
输出：[[2],[1]]

提示：

节点数不超过 100 。
每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
图是连通图，你可以从给定节点访问到所有节点。

题解：
1.复制所有点
dfs或者bfs都可以遍历
2.复制所有边
map将原点映射为新的点

代码：

/*
// 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:
    /*
    1.复制所有点
    dfs或者bfs都可以遍历
    2.复制所有边
    map将原点映射为新的点
    */
    unordered_map<Node*,Node*> hash;

    Node* cloneGraph(Node* node) {
        if(!node) return nullptr;

        dfs(node);  //复制节点
        
        /*
        startvex--->distinatevex
        a--->a
        b--->b
        先找startvex的邻接点
        将startvex的邻接点加到distinatevex的邻接点里面
        */
        for(auto [startvex,distinatevex]:hash){
            for(auto ver:startvex->neighbors){
                distinatevex->neighbors.push_back(hash[ver]);
            }
        }
        return hash[node];
    }

    void dfs(Node* node){
        //用map映射
        hash[node]=new Node(node->val);

        for(auto vex:node->neighbors){
            if(hash.count(vex)==0)    //和定义一个bool数组一样的思想，如果hash里面没有则dfs
                dfs(vex);
        }
    }
};

2.力扣207. 课程表

题目：

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

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
示例 2：

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

提示：

1 <= numCourses <= 105
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对 互不相同

题解：

有向图的拓扑排序
1、统计所有点的入度
入度为0可以走，入度不为0则前面还有先修课没有完成则不能继续
2、队列维护所有当前入度为0的点，将所有入度为0的点入度即d[u]=0的点入队
3、bfs每次从对头取一个点，更新
4、判断所有点是否都遍历完，是否得到拓扑排序
存在拓扑排序====没有环

代码：

class Solution {
public:
    /*有向图的拓扑排序
    1、统计所有点的入度
    入度为0可以走，入度不为0则前面还有先修课没有完成则不能继续
    2、队列维护所有当前入度为0的点，将所有入度为0的点入度即d[u]=0的点入队
    3、bfs每次从对头取一个点，更新
    4、判断所有点是否都遍历完，是否得到拓扑排序
    存在拓扑排序====没有环
    */
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> g(numCourses);   //定义邻接表
        vector<int> d(numCourses);       //记录入度

        //1、统计所有点的入度,构造邻接表
        for(auto& e:prerequisites){
            int b=e[0],a=e[1];  //学习a之前需要学习b
            g[a].push_back(b);
            d[b]++;
        }
        //2、队列维护所有当前入度为0的点，将所有入度为0的点入度即d[u]=0的点入队
        queue<int> q;
        for(int i=0;i<numCourses;i++){
            if(d[i]==0)
                q.push(i);
        }
        // 3、bfs每次从对头取一个点
        int res=0;
        while(q.size()){
            auto t=q.front();
            q.pop();
            res++;
            for(auto i:g[t]){
                if(--d[i]==0){
                    q.push(i);
                }
            }
        }
        return res==numCourses;
    }
};

PS：拓扑排序：

有向图的拓扑序列