【算法】DFS 系列之 穷举/暴搜/深搜/回溯/剪枝（上篇）

于 2024-09-27 11:03:51 发布
阅读量823 收藏 6
点赞数 18
文章标签： 深度优先 算法 剪枝 leetcode c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waluolandao/article/details/142448383
版权

【ps】本篇有 9 道 leetcode OJ。 

目录

一、算法简介

二、相关例题

1）全排列

.1- 题目解析

.2- 代码编写

2）子集

.1- 题目解析

.2- 代码编写

3）找出所有子集的异或总和再求和

.1- 题目解析

.2- 代码编写

4）全排列 II

.1- 题目解析

.2- 代码编写

5）电话号码的字母组合

.1- 题目解析

.2- 代码编写

6）括号生成

.1- 题目解析

.2- 代码编写

7）组合

.1- 题目解析

.2- 代码编写

8）目标和

.1- 题目解析

.2- 代码编写

9）组合总和

.1- 题目解析

.2- 代码编写

一、算法简介

        回溯算法是一种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。

        回溯算法的基本思想：从一个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态无法前进时，回退到前一个状态，再按照其他的规则搜索。回溯算法在搜索过程中维护一个状态树，通过遍历状态树来实现对所有可能解的搜索。

        回溯算法的核心思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜索，否则，回退到上一个状态，重新做出选择。回溯算法通常用于解决具有多个解，且每个解都需要搜索才能找到的问题。

// 回溯算法的模板
void dfs(vector<int>& path, vector<int>& choice, ...)
{
	// 满⾜结束条件
	if (/* 满⾜结束条件 */)
	{
		// 将路径添加到结果集中
		res.push_back(path);
		return;
	}
	// 遍历所有选择
	for (int i = 0; i < choices.size(); i++)
	{
		// 做出选择
		path.push_back(choices[i]);
		// 做出当前选择后继续搜索
		dfs(path, choices);
		// 撤销选择
		path.pop_back();
	}
}

        其中， path 表示当前已经做出的选择， choices 表示当前可以做的选择。在回溯算法中，我们需要做出选择，然后递归地调用回溯函数。如果满足结束条件，则将当前路径添加到结果集中。

        否则，我们需要撤销选择，回到上一个状态，然后继续搜索其他的选择。回溯算法的时间复杂度通常较高，因为它需要遍历所有可能的解。但是，回溯算法的空间复杂度较低，因为它只需要维护一个状态树。在实际应用中，回溯算法通常需要通过剪枝等方法进行优化，以减少搜索的次数，从而提高算法的效率。

        回溯算法是一种非常重要的算法，可以解决许多组合问题、排列问题和搜索问题等。回溯算法的核心思想是搜索状态树，通过遍历状态树来实现对所有可能解的搜索。回溯算法的模板非常简单，但是实现起来需要注意一些细节，比如何做出选择、如何撤销选择等。

二、相关例题

1）全排列

46. 全排列

.1- 题目解析

        全排列的过程，其实可以画成一棵决策树，而找出全排列的结果，其实就是对这棵决策树进行 DFS。

         DFS 的思路是，循环模仿遍历树的结点，到叶子结点就返回，不是就进入循环。

        在下面 for 循环里要考虑这个位置要填哪个数。根据题目要求，我们肯定不能填已经填过的数，因此很容易想到的一个处理手段就是，定义一个标记数组来标记已经填过的数，那么在填这个数的时候，我们遍历题目给定的所有数，如果这个数没有被标记过，我们就尝试填入，并将其标记，继续尝试填下一个位置。而回溯的时候，要撤销这一个位置填的数以及标记，并继续尝试其他没被标记过的数。

.2- 代码编写

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool check[7];
public:
    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums);
        return ret;
    }
    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size())
        {
            ret.push_back(path);
            return ;
        }
        for(int i=0;i<nums.size();i++)//枚举每一个在排列开头的数
        {
            if(check[i]==false)
            {
                //记录结果并遍历下一层
                path.push_back(nums[i]);
                check[i]=true;
                dfs(nums);
                //回到这一层再恢复现场
                path.pop_back();
                check[i]=false;
            }
        }
    }
};

2）子集

78. 子集

.1- 题目解析

        本题有两种解法。

        第一种与上一道题类似，根据某一个元素选或不选，将所有的子集穷举出来，然后统计结果即可。

        第二种解法则是根据子集中有多少个元素，来将所有的子集穷举出来。

.2- 代码编写

//解法一
class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }
    void dfs(vector<int>& nums,int i)
    {
        if(i==nums.size())
        {
            ret.push_back(path);
            return;
        }
        //不选
        dfs(nums,i+1);
        //选
        path.push_back(nums[i]);//记录结果
        dfs(nums,i+1);
        path.pop_back();//恢复现场
    }
};
//解法二
class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }
    void dfs(vector<int>& nums,int pos)
    {
        ret.push_back(path);//每次进到下一层，都是新结果，都要记录
        for(int i=pos;i<nums.size();i++)//枚举下一层
        {
            path.push_back(nums[i]);//记录结果
            dfs(nums,i+1);          //进入下一层
            path.pop_back();        //回到当前层，恢复现场
        }
    }
};

3）找出所有子集的异或总和再求和

1863. 找出所有子集的异或总和再求和

.1- 题目解析

        这道题只需要在上一道的基础上，稍微改变统计结果的方式即可。

.2- 代码编写

class Solution {
    int sum;
    int path;
public:
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return sum;
    }
    void dfs(vector<int>& nums,int pos)
    {
        sum+=path;
        for(int i=pos;i<nums.size();i++)
        {
            path^=nums[i];
            dfs(nums,i+1);
            path^=nums[i];
        }
    }
};

4）全排列 II

47. 全排列 II

.1- 题目解析

        我们可以直接在上文《全排列》的基础上用 set 对结果去重。

        或者，在上文《全排列》的基础上，加入剪枝操作。由于题目不要求返回的排列顺序，因此我们可以对初始状态排序，将所有相同的元素放在各自相邻的位置，方便之后操作。

.2- 代码编写

//解法一：set去重
class Solution {
    set<vector<int>> ret;
    vector<int> path;
    bool cheak[8] = {false};
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        dfs(nums);
        vector<vector<int>> tmp(ret.begin(), ret.end());
        return tmp;
    }
    void dfs(vector<int> nums)
    {
        if(nums.size() == path.size())
        {
            // if(find(ret.begin(), ret.end(), path) == ret.end())
            //     ret.push_back(path);
            ret.insert(path);
            return;
        }
        for(int i = 0; i < nums.size(); ++i)
        {
            if(cheak[i] == false) // 如果没有用过
            {
                path.push_back(nums[i]);
                cheak[i] = true;
                dfs(nums); // 此时路径已经加上一个了，在让其进入递归
                path.pop_back(); // 回溯，恢复现场，（递归往回走了）
                cheak[i] = false;
            }
        }
    }
};
//解法二：剪枝，关心不合法的分支
class Solution {
    vector<int> path;
    vector<vector<int>> ret;
    bool check[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums);
        return ret;
    }
    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();i++)
        {
            if(check[i]==true
            || (i!=0 && nums[i]==nums[i-1] && check[i-1]==false))
            {
                continue;
            }

            path.push_back(nums[i]);
            check[i]=true;
            dfs(nums);
            path.pop_back();
            check[i]=false;
        }
    }
};
//解法三：剪枝，关心合法的分支
//解法二：剪枝
class Solution {
    vector<int> path;
    vector<vector<int>> ret;
    bool check[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums);
        return ret;
    }
    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();i++)
        {
            if(check[i]==false && (i==0 || nums[i]!=nums[i-1] || check[i-1]==true))//剪枝
            {
                path.push_back(nums[i]);
                check[i]=true;
                dfs(nums);
                path.pop_back();
                check[i]=false;
            }
        }
    }
};

5）电话号码的字母组合

17. 电话号码的字母组合

.1- 题目解析

        每一个数字都对应了一串字符，我们可以由此用一个哈希表建立数字和字符之间的映射，以便通过数字找到相应的字符。

        而其他过程同上文中的题目，通过画决策树 + DFS 来解决。

.2- 代码编写

class Solution {
    string hash[10]={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    vector<string> ret;
    string path;
public:
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0)return ret;
        dfs(digits,0);
        return ret;
    }
    void dfs(string& digits,int pos)
    {
        if(pos==digits.size())
        {
            ret.push_back(path);
            return;
        }

        for(auto ch:hash[digits[pos]-'0'])
        {
            path.push_back(ch);
            dfs(digits,pos+1);
            path.pop_back();
        }
    }
};

6）括号生成

22. 括号生成

.1- 题目解析

.2- 代码编写

class Solution {
    int left,right,n;
    string path;
    vector<string> ret;
public:
    vector<string> generateParenthesis(int _n) {
        n=_n;
        dfs();
        return ret;
    }
    void dfs()
    {
        if(right==n)
        {
            ret.push_back(path);
            return ;
        }
        if(left<n)
        {
            path.push_back('(');left++;
            dfs();
            path.pop_back();left--;
        }
        if(right<left)
        {
            path.push_back(')');right++;
            dfs();
            path.pop_back();right--;
        }
    }
};

7）组合

77. 组合

.1- 题目解析

        本题是上一道题的变形，画决策树穷举出所有情况即可。

.2- 代码编写

class Solution {
    vector<int> path;
    vector<vector<int>> ret;
    int n,k;
public:
    vector<vector<int>> combine(int _n, int _k) {
        n=_n,k=_k;
        dfs(1);
        return ret;
    }
    void dfs(int start)
    {
        if(path.size()==k)
        {
            ret.push_back(path);
            return;
        }

        for(int i=start;i<=n;i++)
        {
            path.push_back(i);
            dfs(i+1);
            path.pop_back();
        }
    }
};

8）目标和

494. 目标和

.1- 题目解析

.2- 代码编写

class Solution {
int ret,aim;
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        aim=target;
        dfs(nums,0,0);//参数：原始数组、当前下标位置、决策树某一条路径之和
        return ret;
    }
    void dfs(vector<int>& nums,int pos,int path)
    {
        if(pos==nums.size())
        {
            if(path==aim)ret++;//统计结果
            return;
        }

        dfs(nums,pos+1,path+nums[pos]);//穷举加

        dfs(nums,pos+1,path-nums[pos]);//穷举减

    }
};

9）组合总和

39. 组合总和

.1- 题目解析

 

.2- 代码编写

//解法一：枚举每个值之和
class Solution {
    int aim;
    vector<int> path;
    vector<vector<int>> ret;
public:
    vector<vector<int>> combinationSum(vector<int>& nums, int target) {
        aim=target;
        dfs(nums,0,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos,int sum)
    {
        if(sum==aim)
        {
            ret.push_back(path);
            return;
        }
        if(sum>aim || pos==nums.size())return;//回溯
        for(int i=pos;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i,sum+nums[i]);
            path.pop_back();
        }
    }
};
//解法二：枚举每个值的个数
class Solution {
    int aim;
    vector<int> path;
    vector<vector<int>> ret;
public:
    vector<vector<int>> combinationSum(vector<int>& nums, int target) {
        aim=target;
        dfs(nums,0,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos,int sum)
    {
        if(sum==aim)
        {
            ret.push_back(path);
            return;
        }
        if(sum>aim || pos==nums.size())return;//回溯

        for(int k=0;k*nums[pos]<=aim;k++) //枚举个数
        {
            if(k)path.push_back(nums[pos]);
            dfs(nums,pos+1,sum+k*nums[pos]);
        }

        for(int k=1;k*nums[pos]<=aim;k++)
        {
            path.pop_back();
        }
    }
};

NeeEk0
关注
穷举vs暴搜vs深搜vs回溯vs剪枝
天行健、君子以自强不息
08-06 756
回溯、剪枝、深搜 OJ 题
【ONE·基础算法 || 回溯和剪枝（暴搜/深搜）】
上士闻道，勤而行之。觉纷扰则静坐，觉懒看书则且看书 ♪(´▽｀)
05-05 1020
主要内容：编程题举例，熟悉理解回溯剪枝类题型（如何画决策树，如何使用深搜进行递归，如何运用剪枝，如何在一维数组/二维数组中使用）。
【算法专题】穷举vs暴搜vs深搜vs回溯vs剪枝
无聊_人的博客
09-12 1202
接着，我们开始考虑dfs函数所需要做的事情，对于决策树的每个节点，dfs要做的事情无非是：存放数组元素的情况，此时需要把当前数组元素存到path，然后递归调用自己，进入决策树的下一层；本题要求我们将全部为0的二叉树去掉，也就是剪枝，当我们举一个具体的例子进行模拟时，会发现，只关注于对其中一个子树的根节点进行剪枝，由于我们只去掉所有节点都是0的子树，所以需要先判断它的左子树是否被去掉，右子树是否被去掉，最后再判断根节点本身的值是否为0，如果这三个条件全部满足，我们需要告诉这个子树的父亲，该子树被去掉了。
DFS算法专题(二)——穷举vs暴搜vs深搜vs回溯vs剪枝【OF决策树】
2401_83595513的博客
09-09 1231
DFS算法专题(二)
【递归、搜索与回溯】穷举vs暴搜vs深搜vs回溯vs剪枝
fight_p的博客
06-11 1403
管他什么深搜、回溯还是剪枝，画出决策树就完事了~~~
递归、搜索与回溯算法——穷举vs暴搜vs深搜
m0_60963435的博客
04-20 1095
T04BF👋专栏:🫵 小比特 大梦想此篇文章与大家分享递归、搜索与回溯算法关于穷举vs暴搜vs深搜的专题如果有不足的或者错误的请您指出!
算法3----穷举&暴搜&回溯&剪枝
luyuanqing_029的博客
09-12 304
给出一个数组nums[1,2,3]，返回其所有的全排列为[1,2,3]，[1,3,2]，[2,3,1]，[2,1,3]，[3,1,2]，[3,2,1].（表示每一条排列，将其记录在path中，再由path放进ret中）（标记位置，看是否被使用过·，从而决定是否要使用该条路径）dfs(nums，pos)（pos表示位置，当前位置该从何处进行枚举）选的话：path+=nums[i]，dfs(nums,i)int[][] ret;（表示最终要返回的所有排列）int[][] ret;
30.递归、搜索、回溯之穷举VS暴搜VS回溯VS剪枝
m0_47017197的博客
09-17 242
回溯算法是⼀种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。回溯算法的基本思想：从⼀个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态⽆法前进时，回退到前⼀个状态，再按照其他的规则搜索。回溯算法在搜索过程中维护⼀个状态树，通过遍历状态树来实现对所有可能解的搜索。回溯算法的核心思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜索；否则，回退到上⼀个状态，重新做出选择。回溯算法通常⽤于解决具有多个解，且每个解都需要搜索才能找到的问题。总结。
深度优先搜索(DFS) 总结(算法+剪枝+优化总结)
热门推荐
HeartFireY的博客
11-10 6万+
深度优先搜索(DFS) 总结(算法+剪枝+优化总结) 本文中会引用部分实例、文献资料来自不同的作者之手，由于资料整理比较困难，转载地址不在文中列举。如有侵权请联系我更换或删除！对于提供题解思路的各位大佬和作者：非常感谢！ 一、前导 定义上的深度优先搜索的思路与树的先序遍历非常相似，是针对图的搜索而提出的一种算法，下面是算法导论上的解释： 在深度优先搜索中，对于最新发现的顶点，如果它还有以此为顶点而未探测到的边，就沿此边继续探测下去，当顶点v的所有边都已被探寻过后，搜索将回溯到发现顶点v有起始点的那些边
数据结构与算法分析（十七）--- 怎么用回溯剪枝高效穷举所有可行解？
流云
01-10 1446
当我们遇到一个比较复杂的问题时，通常会想到将一个复杂的问题分解为多个简单的等价子问题去解决。关键是如何分解复杂问题呢？我们可以从两个大的维度去分解：一个是从空间维度上将原大规模问题分解为多个等价的小规模子问题，再把容易求得的小规模子问题的解合并即可得到原大规模问题的解，这就是分治算法；另一种是从时间维度上将原多阶段决策问题分解为多个等价的单阶段决策子问题，再按照DFS 深度优先遍历顺序尝试所以的决策组合，所有满足约束条件的解的组合共同构成原多阶段决策问题的解，这就是回溯剪枝算法，本文以排列组合为例介绍其原理
深度优先搜索 - DFS（暴搜）
qq_61386381的博客
02-15 2353
DFS思路应用-穷举求解问题 在无路可走时，我们往往会选择搜索算法，因为我们期望利用计算机的高性能来有目的的穷举一个问题的部分甚至所有可能情况，从而在这些情况中寻找符合题目要求的答案。这也是“爆搜”之名的 由来 我们约定，对于问题的介入状态，叫初始状态，要求的状态叫目标状态。 这里的搜索就是对实时产生的状态进行分析检测，直到得到一个目标状态或符合要求的最佳状态为止。对于实时产生新的状态的过程叫扩展（由一个状态，应用规则，产生新状态的过程） 搜索的要点： 选定初始状态，在某些问题中可能是从多.
回溯-剪枝
qq_41648804的博客
08-13 719
回溯算法也可以认为是某种程度的暴力穷举，但是在暴力穷举的过程中，可以根据解的相关性质将不满足条件的解及时剪枝 相关例题 括号生成 数字 n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。 示例 1： 输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()()"] class Solution { public: vector<string> vec; void df...
基础-深度优先搜索（DFS）
Ice_teapoy的博客
02-19 2097
1 深度优先搜索（DFS） 1.1 定义 先说什么是搜索。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。在忽略效率的情况下，没有什么是搜索解决不了的（？ 深度优先搜索（DFS）是基于递归的搜索。 想象你在走迷宫： 1、 这个方向有路可走，我没走过 2、 往这个方向前进 3、 是死胡同（到达了已经走过的地方），往回走，回到上一个路口 4、 重复第一步，直到找着出口 通过这种方式，只要地点的数量是有限的，你就一定可以在有限的时间找到迷宫的出口（或者确
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5153
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 482
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
python 实现harmonic series调和级数算法
luthane的博客
09-24 820
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
【优选算法】（第一篇）
最新发布
weixin_73861555的博客
09-25 946
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值