LeetCode刷题记录--深度优先搜索(bfs,dfs,拓扑排序)

爱吃烤秋刀鱼

已于 2022-04-19 05:40:44 修改

阅读量673

点赞数 2

分类专栏： LeetCode刷题记录文章标签： leetcode c++ 图搜索算法广度优先深度优先

于 2022-04-18 19:14:30 首次发布

本文链接：https://blog.csdn.net/m0_67739923/article/details/124246685

版权

LeetCode刷题记录专栏收录该内容

21 篇文章 0 订阅

订阅专栏

文章目录

1.207. 课程表
2.112. 路径总和
3.113. 路径总和 II
4.130. 被围绕的区域
5.133. 克隆图
6.210. 课程表 II
7.1028. 从先序遍历还原二叉树

1.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 <= 10^5
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对互不相同

这道题就十分简单了，我们吧prerequisites中的每个元素建边，并在建边的过程中统计每个课程的入度，接着再进行拓扑排序并，如果发现最后还有课程的入度不为0，就返回false，否则返回true

class Solution {
public:
    #define maxn 100005
    vector<int> edegs[maxn];//建立边集
    int ins[maxn];//统计入度
    void addEdges(int u,int v){
        edegs[u].push_back(v);
        ins[v]++;//要学习的课程的入度++
    }
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        for(int i=0;i<maxn;i++){
            edegs[i].clear();
        }
        memset(ins,0,sizeof(ins));
        for(int i=0;i<prerequisites.size();i++){
            int u=prerequisites[i][1];
            int v=prerequisites[i][0];
            //要学习v必须要先学习u，所以从u到v建边
            addEdges(u,v);
        }
        queue<int> q;//开始进行拓扑排序
        for(int i=0;i<numCourses;i++){
            if(ins[i]==0){
                q.push(i);//入度为0的课程首先入队
            }
        }
        while(!q.empty()){
            int u=q.front();
            q.pop();
            for(int i=0;i<edegs[u].size();i++){
               --ins[edegs[u][i]];//减去u的每条边的入度
               if(ins[edegs[u][i]]==0){
                   q.push(edegs[u][i]);//如果v的入度减去后也为0入队
               }
            }
        }
        for(int i=0;i<numCourses;i++){
            if(ins[i]){
                return false;//最后统计要学习的课程入度是否都为0
            }
        }
        return true;
    }
};

2.112. 路径总和

原题链接

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点是指没有子节点的节点。
示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
示例 2
输入：root = [1,2,3], targetSum = 5
输出：false
不存在 sum = 5 的根节点到叶子节点的路径。
示例 3：
输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

先序遍历即可。

class Solution {
public:
    bool dfs(TreeNode* root,int targetSum){
        if(root==nullptr){
            return false;
        }
        if(root->left==nullptr&&root->right==nullptr){
            return targetSum==0;//题目要求必须到叶结点才能返回
        }
        if(root->left){
            if(dfs(root->left,targetSum-root->left->val)){
                return true;
            }
        }
        if(root->right){
            if(dfs(root->right,targetSum-root->right->val)){
                return true;
            }
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root){
            return false;
        }
        return dfs(root,targetSum-root->val);
    }
};

3.113. 路径总和 II

原题链接

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。
叶子节点是指没有子节点的节点。
示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]
示例 2：
输入：root = [1,2,3], targetSum = 5
输出：[]
示例 3：
输入：root = [1,2], targetSum = 0
输出：[]
提示：
树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

这道题在上一道题的基础上要我们返回所有从根结点到叶子结点的和等于targetSum的路径，也就是说我们在搜索的时候要保存路径，这就很自然的想到 $d f s$ 了.
$1)$ 首先创建返回数组和储存路径的栈，这里用vector也可以模拟，首先如果root为空当然要返回空数组
$2)$ 接着在tmp中先加入root->val,然后开始搜索，如果当前结点为空直接返回，如果当前节点为叶子结点我们去看当前的 $t a r g e t S u m$ 是否为0，如果是的话加入当前储存的路径，之后返回。否则直接返回。这些事搜索结束的条件。
$3)$ 之后就相当于二叉树的前序遍历了，如果当前节点有左子树就现在tmp中加入左子树根节点的 $v a l$ ，然后从左子树开始搜索，搜索完成后要吧tmp中储存的当前一个路径删除。右子树也是同理。最后搜索结束返回我们的ans即可。

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> tmp;
    void dfs(TreeNode* root,int targetSum){
        if(!root){
            return ;
        }
        if(!root->left&&!root->right){
            if(targetSum==0){
                ans.push_back(tmp);
            }
            return ;
        }
        if(root->left){
            tmp.push_back(root->left->val);
            dfs(root->left,targetSum-root->left->val);
            tmp.pop_back();
        }
        if(root->right){
            tmp.push_back(root->right->val);
            dfs(root->right,targetSum-root->right->val);
            tmp.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(!root){
            return {};
        }
        tmp.push_back(root->val);
        dfs(root,targetSum-root->val);
        return ans;
    }
};

4.130. 被围绕的区域

给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。
示例 1：

输入：board = [[“X”,“X”,“X”,“X”],[“X”,“O”,“O”,“X”],[“X”,“X”,“O”,“X”],[“X”,“O”,“X”,“X”]]
输出：[[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“O”,“X”,“X”]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
示例 2：
输入：board = [[“X”]]
输出：[[“X”]]
提示：
m == board.length
n == board[i].length
1 <= m, n <= 200
board[i][j] 为 ‘X’ 或 ‘O’

这道题也十分简单，我们对边界上的 $O$ 来进行搜索可以到达他的所有的 $O$ ,并进行标记，最后再把所有未标记的 $O$ 变成 $X$ 即可。

class Solution {
public:
    int row,col;
    int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    bool vis[205][205];
    void dfs(vector<vector<char>>&board,int x,int y){
        if(vis[x][y]){
            return ;//如果从该点搜索过直接返回.
        }
        vis[x][y]=true;//首先是从边进行搜索，不存在先从中间开始的情况。可以先进行标记
        for(int i=0;i<4;i++){
            int tx=dir[i][0]+x;
            int ty=dir[i][1]+y;
            if(tx<0||ty<0||tx>=row||ty>=col||board[tx][ty]=='X'){
                continue;
            }//越界或者邻边为x直接continue
            dfs(board,tx,ty);
        }
    }
    void solve(vector<vector<char>>& board) {
        row=board.size(),col=board[0].size();
        memset(vis,false,sizeof(vis));
        for(int i=0;i<row;i++){
            if(board[i][0]=='O'){
                dfs(board,i,0);
            }
            if(board[i][col-1]=='O'){
                dfs(board,i,col-1);
            }//对于行搜索邻边的两列
        }
        for(int i=0;i<col;i++){
            if(board[0][i]=='O'){
                dfs(board,0,i);
            }
            if(board[row-1][i]=='O'){
                dfs(board,row-1,i);
            }//对于列搜索邻边的两行
        }
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(board[i][j]=='O'&&!vis[i][j]){
                    board[i][j]='X';//如果该点为O并且没有被标记过改为X
                }
            }
        }
    }
};

5.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 的邻居。
图是连通图，你可以从给定节点访问到所有节点。

既然是要求我们深拷贝一份连通图，那就直接遍历一遍原图，在遍历的途中拷贝就行了.

class Solution {
public:
    unordered_map<Node*,Node*> map;
    Node* dfs(Node* node){
        if(map[node]) return map[node];//如果之前已经克隆过了直接跳过
        Node* newnode= new Node(node->val);//开始构造新的点
        map[node]=newnode;//对新建的点进行标记
        for(int i=0;i<node->neighbors.size();i++){
            newnode->neighbors.push_back(dfs(node->neighbors[i]));
            //添加边
        }
        return newnode;
    }
    Node* cloneGraph(Node* node) {
        if(!node) return nullptr;
        return dfs(node);//dfs搜索node的每个边并返回该点
    }
};

6.210. 课程表 II

原题链接

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前必须先选修 bi 。
例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回任意一种就可以了。如果不可能完成所有课程，返回一个空数组。
示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：[0,1]
解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
示例 2：
输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
输出：[0,2,1,3]
解释：总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
示例 3：
输入：numCourses = 1, prerequisites = []
输出：[0]

这个就只需要我们在课程表那个题的基础上保存一下路径就行了，也没有什么难度。不过需要注意的一点是，如果我们要返回 $a n s$ 的话必须要将所有的课程都学完，也就是说 $a n s . s i z e ()$ == $n u m C o u r s e s$ 的时候才可以返回我们的 $a n s$ 否则返回一个空列表即可。

class Solution {
public:
    #define maxn 100005
    vector<int> edges[maxn];
    int ins[maxn];
    vector<int> ans;
    void addEdges(int u,int v){
        edges[u].push_back(v);
        ins[v]++;
    }
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        for(int i=0;i<numCourses;i++){
            edges[i].clear();
        }
        ans.clear();
        memset(ins,0,sizeof(ins));
        for(int i=0;i<prerequisites.size();i++){
            int u=prerequisites[i][1];
            int v=prerequisites[i][0];
            addEdges(u,v);
        }
        queue<int> q;
        for(int i=0;i<numCourses;i++){
            if(ins[i]==0){
                q.push(i);
            }
        }//以上的代码可以先看文章前面的：207.课程表
        while(!q.empty()){
            int u=q.front();
            q.pop();
            ans.push_back(u);
            //因为是可以返回任意顺序，所以只要是入度为0均可直接加入到ans中
            for(int i=0;i<edges[u].size();i++){
                int v=edges[u][i];
                --ins[v];
                if(ins[v]==0){
                    q.push(v);
                }
            }
        }
        return ans.size()==numCourses?ans:vector<int>();
    }
};

7.1028. 从先序遍历还原二叉树

原题链接

我们从二叉树的根节点 root 开始进行深度优先搜索。
在遍历中的每个节点处，我们输出 D 条短划线（其中 D 是该节点的深度），然后输出该节点的值。（如果节点的深度为 D，则其直接子节点的深度为 D + 1。根节点的深度为 0）。
如果节点只有一个子节点，那么保证该子节点为左子节点。
给出遍历输出 S，还原树并返回其根节点 root。
示例 1：
输入：“1-2–3--4-5–6--7”
输出：[1,2,5,3,4,6,7]
示例 2：
输入：“1-2–3—4-5–6—7”
输出：[1,2,5,3,null,6,null,4,null,7]
示例 3：
输入：“1-401–349—90–88”
输出：[1,401,null,349,88,90]
提示：
原始树中的节点数介于 1 和 1000 之间。
每个节点的值介于 1 和 10 ^ 9 之间。

这道题很像序列化与反序列化二叉树中的反序列化二叉树操作，我们先看代码:

class Solution {
public:
    TreeNode* recoverFromPreorder(string traversal) {
        stack<TreeNode*> stk;
        TreeNode* root,*cur;
        int rootval=0,sum=0;
        int n=traversal.size();
        for(int i=0;traversal[i];i++){
            if(traversal[i]=='-'){
                sum++;
            }else {
                while(i!=n&&traversal[i]!='-'){
                    rootval=rootval*10+traversal[i]-'0';
                    i++;//碰到连续的数字字符将其转化为数字
                }
                i--;//转化完成之后当前的i指向的一定是“-”或者越界要--
                while(stk.size()>sum){
                    stk.pop();//删除栈顶直到栈内元素数量和新节点深度相等.
                }
                cur=new TreeNode(rootval);//开辟一个新节点
                if(stk.size()==0){
                    root=cur;
                    //如果栈内为空说明还没有插入新节点令根结点等于新开辟的结点
                }else {
                    if(stk.top()->left){
                        stk.top()->right=cur;
                    }else stk.top()->left=cur;
                }
                stk.push(cur);
                sum=0;
                rootval=0;
            }
        }
        return root;
    }
};

$1)$ :读题可以发现，每有一个“ - ”代表下一个结点的深度加一，这样我们就可以利用深度来处理这个题。首先建立一个栈，这个栈中我们每个深度只存一个结点，当要插入新的结点的时候一直删除栈顶直到栈的数量与新的结点深度相等。
$2)$ 接着要处理的就是插入问题，如果栈内没有元素那就说明还没有进行插入操作，令新开辟的结点直接为根结点。如果栈内不为空就要考虑是插入左子树还是右子树的问题了。首先经过删除后的栈顶元素一定是我们要插入元素的父结点，(这个可以自己在脑中推理一下就可以看出来)如果栈顶元素有左子树自然要插入到右子树上，否则要插入到左子树上。插入完成之后将该结点入栈，下一个结点的值 $v a l$ ，深度 $s u m$ 都清0.继续遍历序列