BFS与DFS

最新推荐文章于 2024-09-06 10:50:05 发布

echo_186

最新推荐文章于 2024-09-06 10:50:05 发布

阅读量601

点赞数

分类专栏： leetcode刷题记录文章标签：数据结构算法

本文链接：https://blog.csdn.net/echo_186/article/details/116885959

版权

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

7 篇文章 0 订阅

订阅专栏

BFS与DFS

bfs模板（来自LABULADONG的算法小抄）
- - leetcode111. 二叉树的最小深度
  - leetcode752. 打开转盘锁
网格dfs模版
- 岛屿问题
普通dps
- leetcode 22. 括号生成

BFS 的把问题抽象成图，从一个点开始，向四周开始扩散。一般来说，我们写 BFS算法都是用「队列」这种数据结构，每次将一个节点周围的所有节点加入队列。

BFS 相对 DFS 的最主要的区别是：BFS 找到的路径一定是最短的，但代价就是空间复杂度比 DFS大很多。

bfs模板（来自LABULADONG的算法小抄）

// 计算从起点 start 到终点 target 的最近距离
int BFS(Node start, Node target) {
    Queue<Node> q; // 核心数据结构 队列
    Set<Node> visited; // 避免走回头路
    
    q.push(start); // 将起点加入队列
    visited.add(start);
    int step = 0; // 记录扩散的步数

    while (!q . empty()) {
        int sz = q.size();
        /* 将当前队列中的所有节点向四周扩散 */
        for (int i = 0; i < sz; i++) {
            Node cur = q.front();
            q.pop();//用完就丢
            /* 划重点：这里判断是否到达终点 */
            if (cur is target)
                return step;
            /* 将 cur 的相邻节点加入队列 */
            for (Node x : cur.adj())
                if (x not in visited) {
                    q.push(x);
                    visited.add(x);
                }
        }
        /* 划重点：更新步数在这里 */
        step++;
    }
}

leetcode111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr)
        {
            return 0;
        }
        queue<TreeNode*> q;
        q.push(root);
        int depth=1;
        while(!q.empty())
        {
            int size=q.size();
            for(int i=0;i<size;i++)
            {
                TreeNode *cur=q.front();//用一个丢一个，先进先出
                q.pop();
                if(cur->left==nullptr&&cur->right==nullptr)//结束搜索时机
                {
                    return depth;
                }
                if(cur->left)//
                {q.push(cur->left);
        
                }
                if(cur->right)
                {q.push(cur->right);
                }
                
            }
            depth++;//注意每一轮的深度是一样的，一轮结束后再增加深度



        }
        return depth;
        

    }
};

leetcode752. 打开转盘锁

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。
字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

示例 1:
输入：deadends = [“0201”,“0101”,“0102”,“1212”,“2002”], target = “0202”
输出：6
解释：
可能的移动序列为 “0000” -> “1000” -> “1100” -> “1200” -> “1201” -> “1202” -> “0202”。
注意 “0000” -> “0001” -> “0002” -> “0102” -> “0202” 这样的序列是不能解锁的，
因为当拨动到 “0102” 时这个锁就会被锁定。
示例 2:
输入: deadends = [“8888”], target = “0009”
输出：1
解释：
把最后一位反向旋转一次即可 “0000” -> “0009”。
示例 3:
输入: deadends = [“8887”,“8889”,“8878”,“8898”,“8788”,“8988”,“7888”,“9888”], target = “8888”
输出：-1
解释：
无法旋转到目标数字且不被锁定。
示例 4:
输入: deadends = [“0000”], target = “8888”
输出：-1

本题关键：
1.将死亡节点也看作已走过不可再走的节点记录在used中
2.用string 类型将一个密码看作整体而非用char+for循环对每个字符做bfs这样无法处理死亡节点。

class Solution {
public:
    int openLock(vector<string>& deadends, string target) 
     {   queue<string> q;
     unordered_map <string,bool> used(false);//记录已经走过的路径
     for(int i=0;i<deadends.size();i++)
{
    used[deadends[i]]=true;

}

            q.push("0000");
            int step=0;

            while(!q.empty())
            {
                int size=q.size();
                for(int j=0;j<size;j++)
                {
                    string curr=q.front();
                    q.pop();
                    if(curr==target)//结束条件，找到最短路径
                    return step;
                    if(used[curr]==true)//遇到已经走过的或者不能走的路，跳过
                    continue;
                    used[curr]=true;
                    for(int i=0;i<4;i++)//将curr链接的左节点加入队列
                    {
                        string now=ChangeL(curr,i);
                        q.push(now);
                    }
                        for(int i=0;i<4;i++)//将curr链接的右节点加入队列
                    {
                    string now=ChangeR(curr,i);
                        q.push(now);
                    }


                }
                step++;
                
            }
            return -1;
            }
    
    string ChangeL(string  curr,int i)
    {
            if(curr[i]=='0')
            curr[i]='9';
            else
            curr[i]=curr[i]-1;
            return curr;
    }
        string ChangeR(string  curr,int i)
    {
            if(curr[i]=='9')
            curr[i]='0';
            else
            curr[i]=curr[i]+1;
            return curr;
    }
};

网格dfs模版

0 —— 海洋格子
1 —— 陆地格子（未遍历过）
2 —— 陆地格子（已遍历过）

 void dfs(vector<vector<char>>& grid, int r, int c) {
        //判断 base case {
    // 判断 base case
    if (!inArea(grid, r, c)) {//如果不在网格之中，直接返回
        return;
    }
    //去除重复点与不合法点
      
    if (grid[r][c] = ****) {/
        return;
    }
    //避免重复：
       grid[r][c] = ****; // 将格子标记为「已遍历过」
    
    // 访问上、下、左、右四个相邻结点
    dfs(grid, r - 1, c);
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}

// 判断坐标 (r, c) 是否在网格中
boolean inArea(vector<vector<char>>& grid, int r, int c) {
    return 0 <= r && r < grid.length 
        	&& 0 <= c && c < grid[0].length;
}

作者：nettee
链接：https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-lei-wen-ti-de-tong-yong-jie-fa-dfs-bian-li-/
来源：力扣（LeetCode）

岛屿问题

leetcode200 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1
示例 2：
输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int ans=0;
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[0].size();j++)
            {
                if(grid[i][j]=='1')
                {
                    dfs(grid,i,j);
                    ans++;
                    
                }
            }
        }
        return ans;

    }
    void dfs (vector<vector<char>> &grid,int i,int j)
    {
        if(!(0<=i&&0<=j&&i<grid.size()&&j<grid[0].size()))
        return ;
        if(grid[i][j]!='1')
        return;
        grid[i][j]='2';//标记已经搜索过的点
        dfs(grid,i-1,j);
        dfs(grid,i+1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);

    }

};

leetcode 463. 岛屿的周长

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[0].size();j++)
            {
                if(grid[i][j]==1)
                return bfs(grid,i,j);
            }
        }
        return 0;

    }
    int bfs(vector<vector<int>> &grid,int i,int j)
    {
        if(!(0 <= i && i < grid.size() && 0 <= j && j < grid[0].size()))
        return 1;
        if(grid[i][j]==0)
        return 1;
        if(grid[i][j]!=1)
        return 0;
        grid[i][j]=2;
        return (bfs(grid,i+1,j)+bfs(grid,i-1,j)+bfs(grid,i,j+1)+bfs(grid,i,j-1));
    }
};

leetcode695 岛屿最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid，一个岛屿是一组相邻的 1（代表陆地），这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表海洋）包围着。
找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

class Solution {
public:

    int maxAreaOfIsland(vector<vector<int>>& grid) {
               int ans=0;
               int ma=0;
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[0].size();j++)
            {
                if(grid[i][j]==1)
                {
                    ma=dfs(grid,i,j);
                   ans=max(ma,ans);
                    
                }
            }
        }
        return ans;


    }
    int dfs(vector<vector<int>>& grid,int i,int j)
    {
        if(!(i>=0&&j>=0&&i<grid.size()&&j<grid[0].size()))
        return 0;
        if(grid[i][j]!=1)
        return 0;
        grid[i][j]=2;
        return 1+dfs(grid,i-1,j)+dfs(grid,i+1,j)+dfs(grid,i,j-1)+dfs(grid,i,j+1);//每次搜索到一个陆地时就把它面积+1；不能用if return这样在搜到第一个陆地时就停止了
        


    }
};

普通dps

leetcode 22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。
有效括号组合需满足：左括号必须以正确的顺序闭合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]

class Solution {
public:
vector<string> ans; 
string path;
    vector<string> generateParenthesis(int n) {
        backtracking(n,0,0);
        return ans;


    }
    void backtracking(int n,int r,int l)
    {
        if(path.length()==n*2)//退出条件
        {
            ans.push_back(path);
            return;
        }
        //每层遍历
            if(r<l)
            {
                path.push_back(')');
                r=r+1;
                backtracking(n,r,l);
                path.pop_back();
                r=r-1;


            }
            if(l<n)
    {        
                path.push_back('(');
                l=l+1;
                backtracking(n,r,l);
                path.pop_back();
                l=l-1;

    }
    }
};