算法合集：回溯

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量217 收藏
点赞数
分类专栏： 算法 文章标签： 算法 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 解数独

明里贵树
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计与分析：回溯法算法思想的应用
Junds0的博客
10-14 642
递归，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 320
把多个情况枚举出来： 在这其中可以使用递归： 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=...
leetcode【递归/回溯问题】总结
ftfy123的博客
10-22 354
回溯问题分析 注意： 整体思路清晰，回溯的过程大概是怎样的 每层递归实际上要解决的问题是什么 一定记住，该重置的状态要重置，因为回溯就是相当于在每一层的递归中做选择，选择了不同的选项，在遇到阻碍或者达到条件结束递归之后，再想尝试其他的选择路径，应当记住回退到之前的状态。 纵向：递归的深度，完整地解决问题（搜索完所有的方案/找到最优方案 ）所必须完成地一整个连续过程，该过程的长度。例如，在“选/不选”递归（0/1递归）中，递归的深度是可选值的数量。 对于纵向思维，要有层层深入，逐渐解决问题的概念。对
利用栈操作实现八皇后问题求解
宇宙观光巴士站
12-05 1607
利用栈操作实现八皇后问题求解 -数据结构题目 思路： 使用递归思想，每一行逐个位置放入皇后，判断是否冲突，若冲突，则试探下一个位置，若不冲突，则继续下一行的递归，直至全部放置完成。 c++代码如下： #include <stdlib.h> #include <iostream> using namespace std; #define StackInitSize 256 //初次分配空间大小 #define StackIncrement 128 //空间分配
【算法思想：回溯法】回溯算法入门级详解
Vermont_的博客
03-01 6662
回溯算法与深度优先遍历 以下是维基百科中「回溯算法」和「深度优先遍历」的定义。 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 深度优先搜索 算法（英语：Depth-Fir
算法与分析实验四：回溯法
02-10
回溯法是一种试探性的搜索策略，它用于在解决问题时尝试所有可能的解决方案，直到找到一个可行的解或者确定没有解存在。在这个实验中，我们利用回溯法来解决三色问题，即给定一个连通无向图G=(V,E)，我们需要用三种...
五大常用算法：回溯算法，算法数据结构
04-07
回溯算法是一种重要的搜索策略，尤其在解决组合优化问题中广泛应用。它通过尝试所有可能的解决方案路径，并在遇到无效或不满足条件的情况时回溯，以寻找其他可能的解。回溯法通常与数据结构结合使用，如数组、栈、...
算法分析与设计实验三：回溯法.doc
10-29
回溯法是一种在解决问题时，通过试探性地做出选择，并逐步深入到可能的解空间，如果发现当前选择无法导出有效解，则退回一步，改变之前的选择，继续探索其他可能的分支，直到找到满足条件的解或者证明无解的搜索算法...
C++程序设计 算法：回溯.ppt
05-24
C++程序设计 算法：回溯.ppt
学习电脑信息五大常用算法之四：回溯法，算法数据结构
04-07
学习电脑信息五大常用算法之四：回溯法，算法数据结构 五大常用算法
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 920
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 218
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 230
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 294
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 529
第 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 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 613
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 278
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到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 926
思路：利用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 255
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值