递归 回溯算法详解

什么是回溯算法

回溯算法是⼀种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。
回溯算法的基本思想：从⼀个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态⽆法前进
时，回退到前⼀个状态，再按照其他的规则搜索。回溯算法在搜索过程中维护⼀个状态树，通过遍历 状态树来实现对所有可能解的搜索。
回溯算法的核⼼思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜
索；否则，回退到上⼀个状态，重新做出选择。回溯算法通常⽤于解决具有多个解，且每个解都需要 搜索才能找到的问题。

回溯算法的应⽤
组合问题: 组合问题是指从给定的⼀组数（不重复）中选取出所有可能的 k 个数的组合。例如，给定数集 [1,2,3]，要求选取 k=2 个数的所有组合。 结果为：

[1,2]
[1,3]
[2,3]

排列问题 排列问题是指从给定的⼀组数（不重复）中选取出所有可能的 k 个数的排列。例如，给定数集 [1,2,3]，要求选取 k=2个数的所有排列。 结果为：

[1,2]
[2,1]
[1,3]
[3,1]
[2,3]
[3,2

⼦集问题 ⼦集问题是指从给定的⼀组数中选取出所有可能的⼦集，其中每个⼦集中的元素可以按照任意顺序排 列。例如，给定数集[1,2,3]，要求选取所有可能的⼦集。 结果为：

[ ]
[1]
[2]
[3]
[1,2]
[1,3]
[2,3]
[1,2,3]

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

题目一： 全排列

1. 题⽬链接：

https://leetcode.cn/problems/permutations/description/

2. 题⽬描述：

3. 解法：

算法思路：

的回溯题⽬，我们需要在每⼀个位置上考虑所有的可能情况并且不能出现重复。通过深度优先搜索的⽅式，不断地枚举每个数在当前位置的可能性，并回溯到上⼀个状态，直到枚举完所有可能性，得到正确的结果。 每个数是否可以放⼊当前位置，只需要判断这个数在之前是否出现即可。

递归流程如下：

1. ⾸先定义⼀个List<List<Integer>> ret⽤来存放所有可能的排列，⼀个 List<Integer> path⽤来存放每个状态的排列，⼀个⼀维数组boolean[] check标记元素，然后从第⼀个位置开始进⾏递归；

2. 递归结束条件：当path.size()等于 nums 数组的⻓度时，说明我们已经处理完了所有数字，将当前数组存⼊结果中；

3. 在每个递归状态中，枚举所有下标 i，若这个下标未被标记，即check[i]==false，则使⽤ nums 数组中当前下标的元素：

   a. 将 check[i] 标记为 true；

   b. path中添加nums[i]

   c. 进入下一层递归

   d. 恢复现场，将 check[i] 标记为 false，表⽰回溯；

4. 最后，返回 ret。

4.代码

class Solution 
{

 List<List<Integer>> ret;
 List<Integer> path;
 boolean[] check;
 public List<List<Integer>> permute(int[] nums) 
 {
 ret = new ArrayList<>();
 path = new ArrayList<>();
 check = new boolean[nums.length];
 dfs(nums);
 return ret;
 }
 public void dfs(int[] nums)
 {
 if(nums.length == path.size())
 {
 ret.add(new ArrayList<>(path));
 return;
 }
 for(int i = 0; i < nums.length; i++)
 {
 if(check[i] == false)
 {
 path.add(nums[i]);
 check[i] = true;
 dfs(nums);
 // 回溯 -> 恢复现场 
 check[i] = false;
 path.remove(path.size() - 1);
 }
 }
 }
}

题目二：⼦集

1. 题⽬链接：

https://leetcode.cn/problems/subsets/description/

2. 题目描述：

3. 解法：

算法思路：

为了获得 nums 数组的所有⼦集，我们需要对数组中的每个元素进⾏选择或不选择的操作，即 nums 数组⼀定存在 2^(数组⻓度)
个⼦集。对于查找⼦集，具体可以定义⼀个数组，来记录当前的状态，并 对其进⾏递归。

对于每个元素有两种选择：1. 不进⾏任何操作；
2. 将其添加⾄当前状态的集合。在递归时我们需要保
证递归结束时当前的状态与进⾏递归操作前的状态不变，⽽当我们在选择进⾏步骤 2 进⾏递归时，当
前状态会发⽣变化，因此我们需要在递归结束时撤回添加操作，即进⾏回溯。
递归函数设计：
public void dfs(int[] nums,int pos)
参数：pos（当前需要处理的元素下标）；
返回值：⽆；
函数作⽤：查找集合的所有⼦集并存储在答案列表中。

递归流程如下：
1.递归结束条件：如果当前需要处理的元素下标越界，则记录当前状态并直接返回；
2. 在递归过程中，对于每个元素，我们有两种选择：

(1)不选择当前元素，直接递归到下⼀个元素；

(2)选择当前元素，将其添加到数组末尾后递归到下⼀个元素，然后在递归结束时撤回添加操作；
3. 所有符合条件的状态都被记录下来，返回即可。

4.代码

// 解法⼀： 

class Solution 
{
 List<List<Integer>> ret;
 List<Integer> path;
 public List<List<Integer>> subsets(int[] nums) 
 {
 ret = new ArrayList<>();
 path = new ArrayList<>();
 dfs(nums, 0);
 return ret;
 }

 public void dfs(int[] nums, int pos)
 {
 if(pos == nums.length)
 {
 ret.add(new ArrayList<>(path));
 return;
 }
 // 选 
 path.add(nums[pos]);
 dfs(nums, pos + 1);
 path.remove(path.size() - 1); // 恢复现场 
 // 不选 
 dfs(nums, pos + 1);
 }
}

// 解法⼆： 

class Solution 
{
 List<List<Integer>> ret;
 List<Integer> path;
 public List<List<Integer>> subsets(int[] nums) 
 {
 ret = new ArrayList<>();
 path = new ArrayList<>();
 dfs(nums, 0);
 return ret;
 }
 public void dfs(int[] nums, int pos)
 {
 ret.add(new ArrayList<>(path));
 for(int i = pos; i < nums.length; i++)
 {
 path.add(nums[i]);
 dfs(nums, i + 1);
 path.remove(path.size() - 1); // 恢复现场 
 }
 }
}