深搜(DFS)和广搜(BFS)：初识问题状态

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量113 收藏
点赞数
文章标签： 深度优先 宽度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45061460/article/details/134116143
版权

搜索的核心概念

这是思维逻辑中的一棵树
在这里插入图片描述
什么是深搜和广搜？
对于问题求解树的不同的遍历方式

什么是搜索剪枝和优化？
排除某些问题的求解树中的子树的遍历过程

设计搜索算法的核心关键点是什么？
设计问题求解树中的状态

广度遍历适合最优化问题

经典面试题 - 深搜广搜系列题目

993. 二叉树的堂兄弟节点

使用深搜

class Solution {
public:
    int dfs(TreeNode *root, int x, TreeNode *&father){
        if(root == nullptr) return -1;
        if(root->val == x) return 0;
        father = root;
        int l;
        l = dfs(root->left, x, father);
        if(l != -1) return l + 1;
        father = root;
        l = dfs(root->right, x, father);
        if(l != -1) return l + 1;
        return -1;
    }
    bool isCousins(TreeNode* root, int x, int y) {
        int d1, d2;
        TreeNode *father_x = nullptr, *father_y = nullptr;
        d1 = dfs(root, x, father_x);
        d2 = dfs(root, y, father_y);
        return d1 == d2 && father_x != father_y;
    }
};

使用广搜

class Solution {
public:
    struct Data{
        Data(TreeNode *node = nullptr, TreeNode *father = nullptr, int deepth = 0)
        :node(node), father(father), deepth(deepth) {}
        TreeNode *node, *father;
        int deepth;
    };
    bool isCousins(TreeNode* root, int x, int y) {
        int d1, d2;
        TreeNode *father_x = nullptr, *father_y = nullptr;
        queue<Data> q;
        q.push(Data(root, 0));
        while(!q.empty()){
            Data cur = q.front();
            if(cur.node->val == x) d1 = cur.deepth, father_x = cur.father;
            if(cur.node->val == y) d2 = cur.deepth, father_y = cur.father;
            if(cur.node->left) {
                q.push(Data(cur.node->left, cur.node, cur.deepth + 1));
            }
            if(cur.node->right) {
                q.push(Data(cur.node->right, cur.node, cur.deepth + 1));
            }
            q.pop();
        }
        return d1 == d2 && father_x != father_y;
    }
};

542. 01 矩阵

class Solution {
public:
    struct Data {
        Data(int i = 0, int j = 0, int k = 0)
        : i(i), j(j), k(k) {}
        int i, j, k;
    };
    void init_queue(
        queue<Data> &q, vector<vector<int>> &vis,
        int n, int m,
        vector<vector<int>> &mat
    ){
        for(int i = 0; i < n; i++){
            vis.push_back(vector<int>());
            for(int j = 0; j < m; j++){
                vis[i].push_back(-1);
            }
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(mat[i][j]) continue;
                vis[i][j] = 0;
                q.push(Data(i, j, 0));
            }
        }
        return;
    }
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size();
        queue<Data> q;
        vector<vector<int>> vis;
        init_queue(q, vis, n, m, mat);
        while(!q.empty()){
            Data cur = q.front();
            for(int k = 0; k < 4; k++){
                int x = cur.i + dir[k][0];
                int y = cur.j + dir[k][1];
                if(x < 0 || x >= n) continue;
                if(y < 0 || y >= m) continue;
                if(vis[x][y] != -1) continue;
                vis[x][y] = cur.k + 1;
                q.push(Data(x, y, cur.k + 1));
            }
            q.pop();
        }
        return vis;
    };
};

1091. 二进制矩阵中的最短路径

  • continue的状态是用来排除非法状态的
class Solution {
public:
    struct Data {
        Data(int i = 0, int j = 0, int l = 0)
        : i(i), j(j), l(l) {}
        int i, j, l;
    };
    int dir[8][2] = { 
        0, 1, 1, 0, 0, -1, -1, 0,
        1, -1, -1, 1, 1, 1, -1, -1
    };
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int n = grid.size();
        vector<vector<int>> vis;
        for(int i = 0; i < n; i++){
            vis.push_back(vector<int>(n));
        }
        queue<Data> q;
        if(grid[0][0]) return -1;
        vis[0][0] = 1;
        q.push(Data(0, 0, 1));
        while(!q.empty()){
            Data cur = q.front();
            if(cur.i == n - 1 && cur.j == n -1) return cur.l;
            for(int k = 0; k < 8; k++){
                int x = cur.i + dir[k][0];
                int y = cur.j + dir[k][1];
                if(x < 0 || x >= n) continue;
                if(y < 0 || y >= n) continue;
                if(grid[x][y]) continue;
                if(vis[x][y]) continue;
                vis[x][y] = 1;
                q.push(Data(x, y, cur.l + 1));
            }
            q.pop();
        }
        return -1;
    }
};

752. 打开转盘锁

class Solution {
public:
    struct Data{
        Data(string s = "", int l = 0)
        : s(s), l(l){}
        string s;
        int l;
    };
    string getS(string &s, int i, int k){
        string ret = s;
        switch(k) {
            case 0: ret[i] += 1; break;
            case 1: ret[i] -= 1; break; 
        }
        if(ret[i] < '0') ret[i] = '9';
        if(ret[i] > '9') ret[i] = '0';
        return ret;
    }
    int openLock(vector<string>& deadends, string target) {
        queue<Data> q;
        unordered_set<string> h;
        for(auto x: deadends) h.insert(x);
        if(h.find("0000") != h.end()) return -1;
        h.insert("0000");
        q.push(Data("0000", 0));
        while(!q.empty()){
            Data cur = q.front();
            if(cur.s == target) return cur.l;
            for(int i = 0; i < 4; i++){
                for(int k = 0; k < 2; k++){
                    string t = getS(cur.s, i, k);
                    if(h.find(t) != h.end()) continue;
                    h.insert(t);
                    q.push(Data(t, cur.l + 1));
                }
            }
            q.pop();
        }
        return -1;
    }
};

130. 被围绕的区域

class Solution {
public:
    int n, m;
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    void dfs(int i, int j, vector<vector<char>> &board){
        board[i][j] = 'o';
        for(int k = 0; k < 4; k++){
            int x = i + dir[k][0];
            int y = j + dir[k][1];
            if(x < 0 || x >= n) continue;
            if(y < 0 || y >= m) continue;
            if(board[x][y] != 'O') continue;
            dfs(x, y, board);
        }
        return ;
    };
    void solve(vector<vector<char>>& board) {
        n = board.size(), m = board[0].size();
        for(int i = 0; i < n; i++){
            if(board[i][0] == 'O') dfs(i ,0, board);
            if(board[i][m - 1] == 'O') dfs(i, m - 1, board);
        }
        for(int j = 0; j < m; j++){
            if(board[0][j] == 'O') dfs(0, j, board);
            if(board[n - 1][j] == 'O') dfs(n - 1, j, board);
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(board[i][j] == 'O') board[i][j] = 'X';
                else if(board[i][j] == 'o') board[i][j] = 'O';
            }
        }
        return;
    }
};

494. 目标和

class Solution {
public:
    int dfs(int i, int target, vector<int> &nums){
        if(i == nums.size()){
            return target == 0;
        }
        int ans = 0;
        ans += dfs(i + 1, target - nums[i], nums); // +
        ans += dfs(i + 1, target + nums[i], nums); // -
        return ans;
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        return dfs(0, target, nums);
    }
};

由于该程序效率太差，使用记忆化进行优化
数组和函数没有差别

class Solution {
public:
    typedef pair<int, int> PII;
    struct CMP {
        int operator()(const PII &a) const {
            return a.first ^ a.second;
        }
    };
    unordered_map<PII, int, CMP> h;
    int dfs(int i, int target, vector<int> &nums){
        if(i == nums.size()){
            return target == 0;
        }
        if(h.find(PII(i, target)) != h.end()){
            return h[PII(i, target)];
        }
        int ans = 0;
        ans += dfs(i + 1, target - nums[i], nums); // +
        ans += dfs(i + 1, target + nums[i], nums); // -
        h[PII(i, target)] = ans;
        return ans;
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        h.clear();
        return dfs(0, target, nums);
    }
};

473. 火柴拼正方形

class Solution {
public:
    bool dfs(int ind, vector<int> &arr, vector<int> &ms){
        if(ind == -1) return true;
        for(int i = 0; i < 4; i++){
            if(arr[i] < ms[ind]) continue;
            if(arr[i] == ms[ind] || arr[i] >= ms[ind] + ms[0]){
                arr[i] -= ms[ind];
                if(dfs(ind - 1, arr, ms)) return true;
                arr[i] += ms[ind];
            }
        }
        return false;
    }
    bool makesquare(vector<int>& matchsticks) {
        sort(matchsticks.begin(), matchsticks.end());
        vector<int> arr(4);
        int sum = 0;
        for(auto x : matchsticks) sum += x;
        for(int i = 0; i < 4; i++) arr[i] = sum / 4;
        return dfs(matchsticks.size() - 1, arr, matchsticks);
    }
};

39. 组合总和

class Solution {
public:
    void dfs(int ind, int target, vector<int> &nums, vector<int> &buff, vector<vector<int>> &ret){
        if(target < 0) return;
        if(target == 0){
            ret.push_back(buff);
            return;
        }
        if(ind == nums.size()) return;
        dfs(ind + 1, target, nums, buff, ret);
        buff.push_back(nums[ind]);
        dfs(ind, target - nums[ind], nums, buff, ret);
        buff.pop_back();
        return;
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> buff;
        vector<vector<int>> ret;
        dfs(0, target, candidates, buff, ret);
        return ret;
    }
};
欢欢学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于深搜和广搜的北京市地铁搜索引擎
02-25
本文将深入探讨一个特别的应用案例——“基于深搜和广搜的北京市地铁搜索引擎”，它巧妙地结合了人工智能（AI）技术和Python编程语言，旨在为用户提供高效、精准的地铁线路查询服务。 首先，我们来了解搜索引擎的...
搜索总结）（深搜和广搜）
绝丶爵的博客
04-26 2108
一．个人理解 （以下只是个人理解，觉的有问题就忽略他）搜索本质就是对图的遍历，也就是考虑全部的情况后找出需要的结果。这和动态规划思想基本一样，不一样的在于优化的方向不同。搜索优化在于剪枝，也就是把不需要的情况减去从而优化（还有对结果预测如A*算法，现在还不大会以后会了在总结吧）。而动态规划则是利用空间记录重复过程的值，从而减少重复遍历而达到优化（有点像递推，从小往大推，保存小的推大时候不用再...
PUZZLE15_dfs_C++求解15拼图问题_bfs_
10-02
**C++实现BFS：** C++中的BFS可以通过使用队列（queue）和一个二维数组来实现。首先，将初始状态加入队列，并初始化步数为0。然后，不断地从队列中取出状态，检查是否达到目标，如果不是，则将所有可能的下一步状态...
C282-DFS-BFS:班级分配-广度优先搜索和深度优先搜索
05-05
在这个名为"C282-DFS-BFS:班级分配"的项目中，我们将探讨如何利用这两种搜索策略来解决实际问题，比如合理地分配班级资源。 首先，DFS是一种递归的搜索策略，它尽可能深地探索图或树的分支，直到达到叶子节点或者...
八数码问题（数字华容道，九宫格）深度搜索（DFS）广度搜索（BFS）和A*算法C++源码
03-27
在计算机科学领域，解决这类问题通常运用图搜索算法，如深度优先搜索（DFS）、广度优先搜索（BFS）以及启发式搜索算法A*。 深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。在八数码问题中，DFS会尽可能深地...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5135
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 872
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 177
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 259
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 504
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 253
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 910
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 210
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 307
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 377
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1024
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1054
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
深搜dfs广搜bfs算法和动态规划dp有什么关系吗
04-01
深搜和广搜算法与动态规划算法在解决问题的方式上有一定的相似之处，但它们主要应用于不同的问题类型。 深搜和广搜算法是用于图和树等数据结构的搜索算法，主要用于寻找图中的路径、遍历树等问题。它们通过搜索所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值