编程疑难点之回溯算法（一）

已于 2023-12-21 15:09:50 修改
阅读量147 收藏
点赞数 4
文章标签： 算法
于 2023-12-20 15:34:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45951205/article/details/135016033
版权

回溯法不能什么高效的算法，但是有些问题除了回溯，并没有可以高效解决的方法。

回溯法可以解决以下问题：

  • 组合问题：N个数里面按一定规则找出k个数的集合
  • 切割问题：一个字符串按一定规则有几种切割方式
  • 子集问题：一个N个数的集合里有多少符合条件的子集
  • 排列问题：N个数按一定规则全排列，有几种排列方式
  • 棋盘问题：N皇后，解数独等等

回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为高度有限的树形结构！

一、回溯法模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

 二、回溯法的剪枝优化

 就是在 for 循环时的判断条件不同，改成：

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

例如：

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]

加上剪枝优化后的代码：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // 优化的地方
            path.push_back(i); 
            backtracking(n, k, i + 1);
            //当数字只能使用一次的时候，就取i+1；可以重复使用就取i
            path.pop_back();
        }
    }
public:

    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1);
        return result;
    }
};

三、疑难问题之电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

  • 输入："23"
  • 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

代码详情：

class Solution {
private:
    const string letterMap[10] = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public:
    vector<string> result;
    string s;
    void backtracking(const string& digits, int index) {//index用来表示遍历到哪个数字
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';        // 将index指向的数字转为int
        string letters = letterMap[digit];      // 取数字对应的字符集
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            // 处理
            backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
            s.pop_back();                       // 回溯
        }
    }
    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

四、疑难问题之分割回文串

 题目：给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

例如：

输入：s = "aab" 输出：[["a","a","b"],["aa","b"]]

分析：

切割问题类似组合问题。切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段.....。递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。 

class Solution {
public:

    vector<vector<string>> result;
    vector<string> path;

    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }

    void backtracking(string s,int index){
        if(index >= s.size()){
            result.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++){
            if(ispartition(s,index,i)){
                string str=s.substr(index,i-index+1);//获取子串
                path.push_back(str);
            }
            else continue;
            backtracking(s,i+1);
            path.pop_back();
        }
    }

    //判断回文串
    bool ispartition(string s,int start,int end){
        for(int i=start,j=end;i<j;i++,j--){
            if(s[i]!=s[j]) return false;
        }
        return true;
    }
};

 五、疑难问题之复原IP地址

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效的 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效的 IP 地址。

  • 输入：s = "25525511135"
  • 输出：["255.255.11.135","255.255.111.35"]
class Solution {
private:
    vector<string> result;// 记录结果

    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                pointNum++;
                backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
                pointNum--;                         // 回溯
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else break; // 不合法，直接结束本层循环
        }
    }

    // 判断字符串s在左闭右闭区间[start, end]所组成的数字是否合法
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) { // 0开头的数字不合法
                return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
                return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255) { // 如果大于255了不合法
                return false;
            }
        }
        return true;
    }

public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }
};

 六、疑难问题之子集问题

 其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！遍历树的时候，把所有节点都记录下来，就是要求的子集集合。

题目：给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例：输入: nums = [1,2,3] 输出: [ [3],   [1],   [2],   [1,2,3],   [1,3],   [2,3],   [1,2],   [] ]

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

七、子集问题的去重

这种题的难点在于：集合有重复元素，但还不能有重复的组合。

都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。

回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。强调一下，树层去重的话，需要对数组排序！

如下图所示：

需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。这个集合去重的重任就是used来完成的。

在candidates[i] == candidates[i - 1]相同的情况下：

  • used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
  • used[i - 1] == false，说明同一树层candidates[i - 1]使用过

为什么 used[i - 1] == false 就是同一树层呢，因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。而 used[i - 1] == true，说明是进入下一层递归，去下一个数，所以是树枝上。

题目：给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

  • 输入: [1,2,2]
  • 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path);
        //这里不需要return，因为要取树上所有的节点

        for (int i = startIndex; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0, used);
        return result;
    }
};

总结

对于组合问题，什么时候需要index呢？

对于一个集合来求解组合的话就需要index，对于多个集合求解组合，各个集合之间互不影响，就不用index。

在树形结构中子集问题是要收集所有节点的结果，而组合问题是收集叶子节点的结果。

垃圾菜鸟学java
关注
回溯算法学习体会
企鹅侠的博客
06-18 3836
回溯算法的学习体会。本文包括回溯算法的引入，编程框架，以及相关例题的详解。希望通过此文，加深读者对回溯算法的理解。
回溯算法实验
12-26
回溯算法是一种基于试探性的深度优先搜索的算法，它用于找到所有（或所有可以接受的）解决方案，通过在解决问题的过程中尝试各种可能的分支，并在早期发现不可行的分支时及时回溯，避免无效的计算。在本实验中，学生...
编程疑难点之回溯算法（二）
weixin_45951205的博客
12-22 53
给你一个整数数组 ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。示例 ： 输入：nums = [4,6,7,7] 输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]] 解题思路：要注意该题与子集去重问题的区别，在本题中同一父节点下的同层上使用过的元素就不能再使用了。 二、排列问题（不含重复
「leetcode」最强回溯算法总结篇！历时21天、画了20张树形结构图、14道精选回溯题目精讲
热门推荐
代码随想录
11-19 2万+
20张树形结构图、14道精选回溯题目，21篇回溯法精讲文章，由浅入深，一气呵成，这是全网最强回溯算法总结！
【代码随想录】回溯算法
Melody_Mar的博客
03-10 902
77和216是一类题，39和40是一类题，这两类题虽然都是组合问题，但解决思路稍有区别，没必要太过比较。和回溯法模板不同，本题将去重和终止条件都放在了for循环里面，而不是回溯函数刚开始的时候。——为什么？
编程常用五大算法 分治算法 动态规划算法 贪心算法 回溯算法 分支限界法
08-07 1014
一、基本概念在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。...
回溯算法总结
JavanLu的博客
12-05 1495
回溯法17. 电话号码的字母组合22. 括号生成 当遇到组合问题的时候，要想到回溯法。 17. 电话号码的字母组合 class Solution { List<String> res = new ArrayList<>(); // 储存隐射关系:这里要用Character Map<Character,String> map = new HashMap<>(); public List<String> letterCo
回溯算法解决八皇后问题（C++实现）
weixin_41993344的博客
02-22 1366
八皇后问题于1848年由国际象棋棋手马克斯·贝瑟尔于1848年提出，即在8*8的国际象棋棋盘上摆放八个皇后，要求任意两个皇后之间不能相互攻击（任意两个皇后不能处于同一行、同一列以及同一对角线上），求出一共有多少种摆放法？
Leetcode刷题笔记——回溯算法
qq_42898642的博客
01-01 1114
本文给大家介绍了Leetcode上和回溯算法相关的题型，回溯是递归的副产品，只要有递归就会有回溯，所以回溯法经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都使用了递归回溯法就是暴力搜索，并不是什么高效的算法，最多再剪枝一下本文给大家介绍的回溯算法如下N个数里面按一定规则找出k个数的集合切割问题：一定字符串按一定的规则有几种切割方式子集问题：一个N个数的集合里有多少符合条件的子集N个数按一定的规则全排列，有几种排列方式。
＜冲刺大厂之算法刷题＞回溯算法
LXYDSF的博客
07-07 330
＜冲刺大厂之算法刷题＞回溯算法
kmp算法要点和难点具体应用场景.zip
05-23
《KMP算法要点和难点：具体应用场景》 KMP（Knuth-Morris-Pratt）算法是一种在字符串中查找子串出现位置的高效算法，由Donald Knuth、James H. Morris和 Vaughan Pratt三位学者于1970年提出。这个算法避免了在主串...
IDEA 算法要点和难点，实际案例应用，代码实例和解析
05-04
IDEA(Integrated Development Environment for Applications) 是一款广受欢迎的Java集成开发环境，由JetBrains公司开发，它提供了丰富的功能和工具来支持各种编程语言的开发，包括但不限于Java、Python、Kotlin等。...
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 556
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 346
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 859
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
生成哈夫曼树
最新发布
TTz012的博客
10-08 123
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1240
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 808
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
C++实现的字符串匹配算法详解
KMP算法通过预处理模式P，构建一个部分匹配表，用于在不匹配时避免不必要的回溯。这个表记录了模式P中每个前缀和后缀的最大公共长度，从而在不匹配时知道可以跳过多少字符。KMP算法的时间复杂度为O(n+m)，效率高于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值