算法笔记：回溯法
1. 回溯法的基本模板
result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return
for 选择 in 选择列表:
do:做选择
backtrack(路径, 选择列表)
do:撤销选择
2. 回溯法的要点
- 在参数里面一般有一个最终的结果集res，有一个路径path，当path符合题意时就被添加到结果集res中。path可以看为一个栈，它从选择列表中选择元素并入栈，当选择不符合条件的时候就会回溯，即撤销最后一个选择，回到选择前的状态，去试另一个选择。
- 不能直接
res.add(path);在 Java 中，参数传递是 值传递，对象类型变量在传参的过程中，复制的是变量的地址。这些地址被添加到 res 变量，但实际上指向的是同一块内存地址，所以需要作一次拷贝，使用res.add(new ArrayList<>(path));如果是字符串则res.add(new Sring(path));。 - 剪枝。回溯算法会应用「剪枝」技巧达到以加快搜索速度。有些时候，需要做一些预处理工作（例如排序）才能达到剪枝的目的。预处理工作虽然也消耗时间，但能够剪枝节约的时间更多。
- 选择。在选择过程中，选择列表中的元素有的可以重复选择，有的不能重复选择，那么有时需要一个参数begin，代表下一次选择从哪里开始。
- 回溯时什么时候要手动删减参数值：在dfs()内部进行+，-的参数不需要在回溯后手动修改其值，直接传递引用的参数需要。比如在下面的代码中sum不需要，而path需要在回溯后删除最后添加的元素。sum是int类型，传值的话，不论内层函数怎么改，都不会影响外层函数的sum的值，但是path就不一样了，是个指针，如果内层函数改了path，外层函数的path也会被修改。
for(int i = begin; i < candidates.length; i++){
path.add(candidates[i]);
dfs(candidates, target, sum + candidates[i], i, res, path);
path.remove(path.size() - 1);
}
3. 数组类回溯法的题解
题目描述：给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
boolean[] bool = new boolean[nums.length];
dfs(res, path, nums, bool);
return res;
}
public void dfs(List<List<Integer>> res, List<Integer> path, int nums[], boolean[] bool){
if(path.size() == nums.length){
res.add(new ArrayList<Integer>(path));
return;
}
for(int i = 0; i < nums.length; i++){
if(!bool[i]){
path.add(nums[i]);
bool[i] = true;
dfs(res, path, nums, bool);
path.remove(path.size() - 1);
bool[i] = false;
}
}
}
}
当nums = [1,2,3] 时，可以画出全排列的树形结构
考虑什么时候把path加入结果集res：由于是全排列，数组中每个数都会取到，所以当path的元素个数和nums元素个数相同时加入。
选择：nums中的元素都只能选取一次，所以下一次选择不能选已经选过的，使用一个used数组保存已经选过的元素。
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> res = new ArrayList<>();
Deque<Integer> path = new ArrayDeque<>();
boolean[] used = new boolean[nums.length];
dfs(nums, res, path, used);
return res;
}
public void dfs(int[] nums, List<List<Integer>> res, Deque<Integer> path, boolean[] used){
if(path.size() == nums.length){
res.add(new ArrayList<>(path));
return;
}
for(int i = 0; i < nums.length; i++){
if(i > 0 && nums[i] == nums[i-1] && !used[i-1]){
continue;
}
if(!used[i]){
path.addLast(nums[i]);
used[i] = true;
dfs(nums, res, path, used);
path.removeLast();
used[i] = false;
}
}
}
}
与上一题类似，但是由于有重复元素，所以先排序使相同的数相邻。
剪枝：nums = [1, 1, 2]，如下图，可以看出选第一个1开始和选第二个1开始的结果是一样的，所以要把这部分剪掉，条件：i > 0 && nums[i] == nums[i - 1]，但如果只有这个条件，会把[1,1’]给剪掉，我们要剪掉的是树的同一层的相同元素，即[1]回退选[1’]要剪枝，而[1]到[1,1’]不需要剪掉，所以再加上条件!used[i-1]。
if (i > 0 && nums[i] == nums[i - 1] && !used[i-1]) {
continue;
}
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
Arrays.sort(candidates);
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
dfs(candidates, target, 0, 0, res, path);
return res;
}
public void dfs(int[] candidates, int target, int sum, int begin, List<List<Integer>> res, List<Integer> path){
if(sum > target){
return;
}
if(sum == target){
res.add(new ArrayList<Integer>(path));
return;
}
for(int i = begin; i < candidates.length; i++){
path.add(candidates[i]);
dfs(candidates, target, sum + candidates[i], i, res, path);
path.remove(path.size() - 1);
}
}
}
在 for 循环中 i 从 begin 开始，初始时 begin = 0；由于可以重复选取元素，所以下一个dfs() 中下一个 begin 的值从 i 开始，如果不能重复取元素，就是 i + 1 开始。
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> res =new ArrayList<>();
List<Integer> path = new ArrayList<>();
Arrays.sort(candidates);
int sum = 0;
dfs(candidates, target, res, path, 0, sum);
return res;
}
public void dfs(int[] candidates, int target, List<List<Integer>> res, List<Integer> path, int begin, int sum){
if(sum == target){
res.add(new ArrayList(path));
return;
}
if(sum > target){
return;
}
for(int i = begin; i < candidates.length; i++ ){
if (i > begin && candidates[i] == candidates[i - 1]) {
continue;
}
path.add(candidates[i]);
dfs(candidates, target, res, path, i + 1, sum+candidates[i]);
path.remove(path.size() - 1);
}
}
}
与上一题的不同在于不能重复选元素，且有相同的元素。不能重复选元素代表参数 begin 在在下一次选取中要从 i + 1 开始。有相同的元素则需要剪枝去重：在下例中，排序过后，candidates = [1, 2, 2, 2, 5]，选第1、2个2还是选第1、3个2所形成的结果[1,2,2]都是一样的，需要去重。
输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[ [1,2,2] , [5] ]
去重方法类似第47题：
if (i > begin && candidates[i] == candidates[i - 1]) {
continue;
}
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, res, path);
return res;
}
public void dfs(int n, int k, int begin, List<List<Integer>> res, Deque<Integer> path){
if(path.size() == k){
res.add(new ArrayList<>(path));
return;
}
if(path.size() > k){
return;
}
for(int i = begin; i <= n; i++){
path.addLast(i);
dfs(n, k, i + 1, res, path);
path.removeLast();
}
}
}
可以看出数组无重复元素，不能重复选，所以简简单单 i + 1 就完事了。
给你一个整数数组 nums ，数组中的元素互不相同 。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。
class Solution {
public List<List<Integer>> subsets(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
Deque<Integer> path = new ArrayDeque<>();
dfs(nums, 0, res, path);
return res;
}
public void dfs(int[] nums,int begin, List<List<Integer>> res, Deque<Integer> path){
res.add(new ArrayList<>(path));
for(int i = begin; i < nums.length; i++){
path.addLast(nums[i]);
dfs(nums, i + 1, res, path);
path.removeLast();
}
}
}
也是很模板的回溯法，只是在把 path 加入 res 中时没有约束条件。
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> res = new ArrayList<>();
Deque<Integer> path = new ArrayDeque<>();
dfs(nums, 0, res, path);
return res;
}
public void dfs(int[] nums, int begin, List<List<Integer>> res, Deque<Integer> path){
res.add(new ArrayList<>(path));
for(int i = begin; i < nums.length; i++){
if(i > begin && nums[i - 1] == nums[i]){
continue;
}
path.addLast(nums[i]);
dfs(nums, i + 1, res, path);
path.removeLast();
}
}
}
与上一题相比无非是有重复元素，则先排序，再剪枝去重，剪枝方法雷同。
4. 总结
- 可以重复选元素，则下一次 begin 从 i 开始（即上一次选择的元素），不可以则从 i + 1 开始（上一次选择的元素的下一个）。
- 数组中有重复元素，先排序再选择。
- 有重复元素的剪枝：基本套路代码为
if(i > begin && nums[i - 1] == nums[i]){ continue; }
扫一扫
1082
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
