算法合集：回溯

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量248 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mlgseminent/article/details/120852993
版权

回溯

说到回溯的算法题，就像是——好像会写但好像又不会写。回溯倒像是一种暴力枚举，另一种形式的dp递推——推不动回去不就是了嘛，搭配上剪枝或能比较快速的推动算法。

一、简单回溯——子集类回溯：选？不选？

诸如子集，全排列这种类型的题目就属于简单类型的回溯——只需要考虑当下是选还是不选
听上去挺抽象的，结合例题就很好理解

1、例题

1）例题一：LeetCode 77 组合
说白了从1 ~ n，选取k个数，返回所有组合
对一个链表，用递归进行维护，当长度小于k时表示还可以继续选数，当长度等于k时则返回

List<List<Integer>> ans;
List<Integer> set;
public List<List<Integer>> combine(int n, int k) {
    this.ans = new ArrayList<>();
    this.set = new ArrayList<>();
    getAns(k, 1);
    return ans;
}

private void getAns(int k, int index) {
    if (k == 0) {
        ans.add(new ArrayList<>(set));
        return;
    }
    // 选
    set.add(index);
    getAns(k - 1, index + 1);
    set.remove(set.size() - 1); // 还原
    // 不选
    getAns(k, index + 1);
}

两个关键点的理解点

  • 利用递归体的栈空间，使得选完之后可以返回原先index的位置，以进行其他的处理
  • 选完之后要还原来消除影响

这题还有一个关键的加速步骤——剪枝

若剩下所有的数都放进去了也占不满k个，则直接返回

private void getAns(int k, int n, int index) {
    if (k == 0) {
        ans.add(new ArrayList<>(set));
        return;
    }
    if (k > n - index + 1) // 剪枝
        return;
    // 选
	set.add(index);
	getAns(k - 1, n, index + 1);
	set.remove(set.size() - 1);
	// 不选
	getAns(k, n, index + 1);
}

2）例题二：LeetCode 46 全排列（数字无重复）
全排列需要讲所有数都要用上，所以此时不再是一直向后寻找待选择的对象，而是每次递归时都要寻找还没有使用过的数
下面提供基于位运算的解法，不了解位运算的可以参考我的另一篇博客：算法合集：位运算——就两个数字还想劝退我？
另外在注释中用boolean数组进行解释

int valid = 0; // boolean[] valid
List<List<Integer>> ans;
List<Integer> set;
public List<List<Integer>> permute(int[] nums) {
    this.ans = new ArrayList<>();
    this.set = new ArrayList<>();
    this.valid = (int)Math.pow(2, nums.length) - 1; // this.valid = new boolean[nums.length]
    getAns(nums, 0, nums.length);
    return ans;
}

private void getAns(int[] nums, int turn, int n) {
    if (turn == n) {
        ans.add(new ArrayList<>(set));
        return;
    }
    for (int i = 0; i < n; i++) // 每层递归都遍历一边来寻找未使用的数
        if (((valid >> i) & 1) == 1) { // if (valid[i] == false)，表示还没用过该数
            valid ^= 1 << i; // valid[i] = true
            set.add(nums[i]);
            getAns(nums, turn + 1, n);
            set.remove(set.size() - 1);
            valid ^= 1 << i; // valid[i] = false，还原
        }
}

3）例题三：LeetCode 47 全排列Ⅱ（数字可以重复）
与上一题不同的是，有重复的数字且不能返回相同的答案。若要加入“判定答案是否相同”的方法体无疑复杂度太大了。
可以考虑以下想法：

如果数组是有序的
那么当上一个数与当前的数相同时，就可以来判断是否会产生重复答案
产生重复答案的情况是：上一个数与当前的数相同，并且上一个数没有被选择时，若仍选择当前的数，就会产生重复

来证明一下：
考虑这个例子

[1, 1, 2]

我们以第一个1打头时
证明图1
当以红1打头时，红1已经被选择了，所以即使后面出现了蓝1，也可以直接选而不会重复
若以第二个1打头时
证明图2
当轮到蓝1打头时，如果红1没有被选，那么就不能去选红1，因为红1已经代表1作为开头过了，选择蓝1的话只会重复地又1开头

  1. 首先，对有序数组，当上一个数与当前的数相同时才会触发——产生相同答案的情况
  2. 当nums[i - 1] = nums[i] = x时，对于数x来说，当index = i - 1时，x第一次出现，并被答案数组收集
  3. 当index = i时，由于x在上一步已经出现过，并且已经作为答案被收集了，所以若nums[i - 1]没被选，再选则nums[i]会产生重复答案

下面提供基于位运算的解法，另外在注释中用boolean数组进行解释

List<List<Integer>> ans;
List<Integer> set;
int valid; // boolean[] valid
public List<List<Integer>> permuteUnique(int[] nums) {
    Arrays.sort(nums);
    this.ans = new ArrayList<>();
    this.set = new ArrayList<>();
    this.valid = (int)Math.pow(2, nums.length) - 1; // this.valid = new boolean[nums.length]
    getAns(nums, 0, nums.length);
    return ans;
}

private void getAns(int[] nums, int count, int n) {
    if (count == n) {
        ans.add(new ArrayList<>(set));
        return;
    }
    for (int i = 0; i < n; i++)
        if (((valid >> i) & 1) == 1) { // if (valid[i] == false)，还没使用过
        	/*
        	 * if (i > 0 && nums[i] == nums[i - 1] && valid[i - 1] == false)
        	 * 		continue;
        	 * 当前数与上一个数相同，并且上一个数未被使用，则跳过当前
        	 */
            if (i > 0 && nums[i] == nums[i - 1] && ((valid >> (i - 1)) & 1) == 1)
                continue;
            valid ^= 1 << i; // valid[i] = true
            set.add(nums[i]);
            getAns(nums, count + 1, n);
            set.remove(set.size() - 1); // 还原
            valid ^= 1 << i; // valid[i] = false
        }
}

2、实战题目

LeetCode 39 组合总数
LeetCode 40 组合总数Ⅱ
LeetCode 216 组合总数Ⅲ
LeetCode 78 子集
LeetCode 90 子集Ⅱ

二、复杂回溯——判断选择是否合法？

相比于简单回溯，复杂回溯仍是“选”与“不选”的问题，但多了一些处理与选择上的要求

1、例题

1）LeetCode 282 给表达式添加运算符
对于每次选择

不选：当前的数字不与前面的数字分隔开，也就是不添加运算符，直接进行下一次递归
选：先添加+，-，*等运算符，后添加当前数字，再进行进行递归

为了防止重复的操作，每次修改运算符时，不需要将运算符及其后的所以数字都删除，只需要直接找到运算符的位置修改即可：
以s = "123"举例，假设当前递归到i = 1，也就是数字2的位置
在这里插入图片描述
此时StringBuilder = "1"，也就是说，需要对当前的2进行处理

  • 若不选，直接添加2后进行下一次递归
  • 若选，则分别添加三个运算符

我们先插入一个'.'为运算符占位，并记录下这个'.'插入的位置，再添加数字
在这里插入图片描述
此时只需要修改.，变成+，-，*即可，而不用重复的删除添加数字了

builder.setCharAt(operIndex, '+');
builder.setCharAt(operIndex, '-');
builder.setCharAt(operIndex, '*');

接下来是递归参数的维护
维护一个long cur，cur表示当前已参与运算的式子的结果，再维护一个 long pre表示上一层的递归的数字，用于乘法的维护：
因为我们知道*的优先级高于-和+
所以当添加*时：
参数解释
乘法的函数体（i + 1，target和n可以先不看）

builder.setCharAt(operIndex, '*');
getAns(i + 1, pre * val, cur - pre + pre * val, target, n); // 进行下一次递归

pre * val：由于乘法的优先级最高，所以本次的val需要和上一层的pre形成一个整体传给下一层，作为下一层的pre
cur - pre + pre * val：由于乘法会使得上一层的pre和当前的val形成一个整体，所以cur的维护需要减去pre，再将pre * val作为整体进行添加

对比加减法的函数体来看

builder.setCharAt(operIndex, '+');
getAns(i + 1, val, cur + val, target, n);
builder.setCharAt(operIndex, '-');
getAns(i + 1, -val, cur - val, target, n);

最后是题解代码

List<String> ans;
StringBuilder builder;
char[] arr;
public List<String> addOperators(String num, int target) {
    this.ans = new ArrayList<>();
    this.builder = new StringBuilder();
    this.arr = num.toCharArray();
    getAns(0, 0L, 0L, target, num.length());
    return ans;
}

private void getAns(int index, long pre, long cur, int target, int n) {
    if (index == n) {
        if (cur == target)
            ans.add(builder.toString());
        return;
    }
    int operIndex = builder.length();
    if (index > 0)
        builder.append('.'); // 占位
    long val = 0;
    for (int i = index; i < n; i++) {
        val = val * 10 + (arr[i] - '0');
        // 直接添加数字，到后面再修改前面的oper
        builder.append(arr[i]);
        // 若index = 0，不能添加oper
        if (index == 0) {
            getAns(i + 1, val, val, target, n);
        } else {
            builder.setCharAt(operIndex, '+');
            getAns(i + 1, val, cur + val, target, n);
            builder.setCharAt(operIndex, '-');
            getAns(i + 1, -val, cur - val, target, n);
            builder.setCharAt(operIndex, '*');
            getAns(i + 1, pre * val, cur - pre + pre * val, target, n);
        }
        if (val == 0) // 排除连着的0的情况
            break;
    }
    builder.setLength(operIndex); // 还原
}

2）LeetCode 301 删除无效括号
我们知道有效的括号组合一定是count('(') = count(')')，即左右括号数量相等
所以可以先遍历字符串，找出哪种的括号多了，记录下需要删除的数量
比如：

s = "((())"，此时需要删除一个左括号

但有例外：

s = ")("，此时左右括号相等，但s是不合法的，需要删除左右括号各一个
s = ")(("，此时需要删除两个左括号和一个右括号

所以先计算至少需要删除的数量，再循环增加数量

this.arr = s.toCharArray();
int countL = 0, countR = 0; // 得到左右括号各自的数量
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == '(') countL++;
    else if (arr[i] == ')') countR++;
}
// 得到左右括号需要删除的数量
int deleteL = Math.max(0, countL - countR), deleteR = Math.max(0, countR - countL);
// 循环增加需要删除的数量，进行递归
for (int i = 0; i <= Math.min(countL, countR); i++)
    getAns(0, deleteL + i, deleteR + i, 0, 0, true, new StringBuilder());

接下来是递归方法体的设计

getAns(int i, int deleteL, int deleteR, int countL, int countR, boolean pre, StringBuilder builder)
  • i对应s的下标，当i == s.length()时即可收集答案
  • deleteL和deleteR表示还需要删除的左右括号的数量
  • countL和countR表示递归到现在所遇到的左右括号的数量，均从0开始
  • pre表示上一个括号是否有被删除，用于剪枝

删：删除当前的括号。
也就是builder不添加此次的括号，并且deleteL和deleteR相应的减少
不删：不删除当前的括号
builder添加此次括号，deleteL和deleteR不变

// 删
if (arr[i] == '(' && (pre || arr[i - 1] != '(') && deleteL > 0)
    getAns(i + 1, deleteL - 1, deleteR, countL, countR, true, builder);
else if (arr[i] == ')' && (pre || arr[i - 1] != ')') && deleteR > 0)
    getAns(i + 1, deleteL, deleteR - 1, countL, countR, true, builder);
// 不删
builder.append(arr[i]);
if (arr[i] == '(')
    getAns(i + 1, deleteL, deleteR, countL + 1, countR, false, builder);
else if (arr[i] == ')')
    getAns(i + 1, deleteL, deleteR, countL, countR + 1, false, builder);
else    
    getAns(i + 1, deleteL, deleteR, countL, countR, false, builder);
builder.deleteCharAt(builder.length() - 1);

剪枝：

  • countR > countL，也就是当前遇到的右括号数量 > 左括号数量，直接返回
  • arr.length - i < deleteL + deleteR，还需要删除的括号数量 > 还没遍历到的括号数量，直接返回
  • 去重，pre || arr[i - 1] != arr[i]，如果上一层的括号与本层的括号种类相同，并且上一层括号没有被删，则此时再删除当前括号会重复：比如s = "(()"，删除第一个左括号而不删第二个左括号，其效果与不删除第一个左括号但删除第二个左括号相同
List<String> ans;
char[] arr;
public List<String> removeInvalidParentheses(String s) {
    this.ans = new ArrayList<>();
    this.arr = s.toCharArray();
    int countL = 0, countR = 0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == '(') countL++;
        else if (arr[i] == ')') countR++;
    }
    int deleteL = Math.max(0, countL - countR), deleteR = Math.max(0, countR - countL);
    for (int i = 0; i <= Math.min(countL, countR); i++) {
        getAns(0, deleteL + i, deleteR + i, 0, 0, true, new StringBuilder());
        // 如果当前的countL和countR找到了答案，则可以返回了
        // 如果没找到答案，则要增加countL和countR，如：s = ")(("
        if (ans.size() != 0) 
            break;
    }
    return ans;
}

private void getAns(int i, int deleteL, int deleteR, int countL, int countR, boolean pre, StringBuilder builder) {
    if (countR > countL || arr.length - i < deleteL + deleteR)
        return;
    if (i == arr.length) {
        ans.add(builder.toString());
        return;
    }
    // 删
    if (arr[i] == '(' && (pre || arr[i - 1] != '(') && deleteL > 0)
        getAns(i + 1, deleteL - 1, deleteR, countL, countR, true, builder);
    else if (arr[i] == ')' && (pre || arr[i - 1] != ')') && deleteR > 0)
        getAns(i + 1, deleteL, deleteR - 1, countL, countR, true, builder);
    // 不删
    builder.append(arr[i]);
    if (arr[i] == '(')
        getAns(i + 1, deleteL, deleteR, countL + 1, countR, false, builder);
    else if (arr[i] == ')')
        getAns(i + 1, deleteL, deleteR, countL, countR + 1, false, builder);
    else    
        getAns(i + 1, deleteL, deleteR, countL, countR, false, builder);
    builder.deleteCharAt(builder.length() - 1);
}

2、实战题目

LeetCode 1980 找出不同的二进制字符串
LeetCode 131 分割回文串
LeetCode 132 分割回文串Ⅱ
LeetCode 140 单词拆分Ⅱ
LeetCode 93 复原IP地址
LeetCode 638 大礼包

三、硬核大题

篇幅原因，单独出一篇来讲解
LeetCode 52 N皇后Ⅱ
LeetCode 51 N皇后
LeetCode 37 解数独

明里贵树
关注
专栏目录
算法设计与分析：回溯法算法思想的应用
Junds0的博客
10-14 737
递归，t=t+1=2，数字0,2,4,6,8与a[1]所组合的整数a[1,2]是能被t=2整除的，设置当前的数字为a[t=2]=0；其中，参数数组a记录满足条件的整除数（整除数长度n超过int64位存储范围，所以用整型数组模拟存储），参数t（初始为1）表示当前整除数长度（t
枚举法 学习笔记
Charles6665的博客
02-12 349
把多个情况枚举出来： 在这其中可以使用递归： AC： 代码： #include<bits/stdc++.h> using namespace std; int value[64],weight[64],volume[64]; bool choose[64]; int wmax,vmax,ans,n=5; void calculate(){ int i,v=0,w=0,temp=...
利用栈操作实现八皇后问题求解
宇宙观光巴士站
12-05 1666
利用栈操作实现八皇后问题求解 -数据结构题目 思路： 使用递归思想，每一行逐个位置放入皇后，判断是否冲突，若冲突，则试探下一个位置，若不冲突，则继续下一行的递归，直至全部放置完成。 c++代码如下： #include <stdlib.h> #include <iostream> using namespace std; #define StackInitSize 256 //初次分配空间大小 #define StackIncrement 128 //空间分配
leetcode【递归/回溯问题】总结
ftfy123的博客
10-22 411
回溯问题分析 注意： 整体思路清晰，回溯的过程大概是怎样的 每层递归实际上要解决的问题是什么 一定记住，该重置的状态要重置，因为回溯就是相当于在每一层的递归中做选择，选择了不同的选项，在遇到阻碍或者达到条件结束递归之后，再想尝试其他的选择路径，应当记住回退到之前的状态。 纵向：递归的深度，完整地解决问题（搜索完所有的方案/找到最优方案 ）所必须完成地一整个连续过程，该过程的长度。例如，在“选/不选”递归（0/1递归）中，递归的深度是可选值的数量。 对于纵向思维，要有层层深入，逐渐解决问题的概念。对
【算法思想：回溯法】回溯算法入门级详解
Vermont_的博客
03-01 8227
回溯算法与深度优先遍历 以下是维基百科中「回溯算法」和「深度优先遍历」的定义。 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 深度优先搜索 算法（英语：Depth-Fir
递归、搜索与回溯算法：回溯，决策树
2301_79881188的博客
04-19 1142
回溯算法是⼀种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。回溯算法的基本思想：从⼀个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态⽆法前进时，回退到前⼀个状态，再按照其他的规则搜索。回溯算法在搜索过程中维护⼀个状态树，通过遍历状态树来实现对所有可能解的搜索。回溯算法的核⼼思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜索；否则，回退到上⼀个状态，重新做出选择。回溯算法通常⽤于解决具有多个解，且每个解都需要搜索才能找到的问题。1.回溯算法的模板。
五大常用算法：回溯算法
daobuxinzi的博客
11-06 2323
回溯法（back tracking）（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。回溯法可以理解为通过选择不同的岔路口寻找目的地，一个岔路口一个岔路口的去尝试找到目的地。如果走错了路，继续返回来找到岔路口的另一条路，直到找到目的地。 回溯法经典题——八皇后： 在国际象棋中，皇后是最强大的一枚棋子，可以吃掉与其在同一行
Python 算法高级篇：回溯算法的优化与剪枝技巧
小蓝枣的博客
10-25 1159
回溯算法是解决组合优化问题的一种经典方法。它通过逐步构建问题的解，同时利用剪枝技巧来减少搜索空间，从而提高算法的效率。本篇博客将深入探讨回溯算法的原理，介绍回溯算法的优化方法和剪枝技巧，并提供详细的解释和示例。
回溯算法:全排列
m0_51436734的博客
04-10 2427
本文解决几个问题： 回溯算法是什么？解决回溯算法相关的问题有什么技巧？如何学习回溯算法？回溯算法代码是否有规律可循？ 其实回溯算法其实就是我们常说的 DFS 算法，本质上就是一种暴力穷举算法。 废话不多说，直接上回溯算法框架。解决一个回溯问题，实际上就是一个决策树的遍历过程。 站在回溯树的一个节点上，你只需要思考 3 个问题： 1、路径：也就是已经做出的选择。 2、选择列表：也就是你当前可以做的选择。 3、结束条件：也就是到达决策树底层，无法再做选择的条件。 如果你不理解这三个词语的解释，没关系，我们后面会
算法：回溯+剪枝
weixin_42067304的博客
12-09 3870
回溯算法的定义： 在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。 解空间树：依据待解决问题的特性，用树结构表示问题的解结构、用叶子表
算法与分析实验四：回溯法
02-10
回溯法是一种试探性的搜索策略，它用于在解决问题时尝试所有可能的解决方案，直到找到一个可行的解或者确定没有解存在。在这个实验中，我们利用回溯法来解决三色问题，即给定一个连通无向图G=(V,E)，我们需要用三种...
五大常用算法：回溯算法，算法数据结构
04-07
回溯算法是一种重要的搜索策略，尤其在解决组合优化问题中广泛应用。它通过尝试所有可能的解决方案路径，并在遇到无效或不满足条件的情况时回溯，以寻找其他可能的解。回溯法通常与数据结构结合使用，如数组、栈、...
算法分析与设计实验三：回溯法.doc
10-29
回溯法是一种在解决问题时，通过试探性地做出选择，并逐步深入到可能的解空间，如果发现当前选择无法导出有效解，则退回一步，改变之前的选择，继续探索其他可能的分支，直到找到满足条件的解或者证明无解的搜索算法...
C++程序设计 算法：回溯.ppt
05-24
C++程序设计 算法：回溯.ppt
STL set
最新发布
hls0611的博客
11-09 205
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 308
100种算法【Python版】第51篇——希尔排序
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 363
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2078
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 911
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
ACM竞赛搜索算法详解：回溯法至遗传算法
此问题的规模虽小，但回溯算法在实际比赛中的应用展示了其在搜索复杂情况下的实用性。 总结来说，ACM竞赛中的搜索算法是选手必备技能，不同的搜索策略适用于不同类型的问题，理解并熟练掌握它们对于提升竞赛成绩至...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值