【刷题】回溯的思考

概述

回溯就是基于深度优先搜索进行遍历所有可能的组合，达到递归的边界或者其它限制条件就返回的搜索方式。
自己刷了一些leetcode题将回溯总结为以下两种基本思路：
DFS()代表实现回溯的递归深搜函数，int[ ] nums为目标数组

1. 每次调用DFS(int index)都是要确认是否选择nums[index]
2. 每次调用DFS( )都是在往某一条递归路径形成的集合中加入第n个数，n代表DFS( )调用栈的深度

每种思路对递归出口的设置也会不同，直接说比较抽象，下面通过例题来解释

例题

例题1

剑指 Offer II 081. 允许重复选择元素的组合
给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的唯一组合数少于 150 个。

示例 1：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

下面是我写的代码(大佬勿喷，仅做示例用0-0)

就是典型的第一种思路，每次调用DFS(index)实际上是在确认当前递归的深搜路径中是否需要加入candidates[index]这个值，由于题意是可以重复加入同一个位置的元素，所以一旦选择了candidates[index]，还可以重复选择，这样下一层的DFS()中index参数就不变；

递归出口也是要根据实际的DFS()含义来看，既然DFS(index)代表在candidates[ ]数组在index位置作出选择，那么自然递归出口是当index到达数组末尾的时候递归返回

int target;
int[] candidates;
List<List<Integer>> res;
public List<List<Integer>> combinationSum(int[] candidates, int target) {
    this.target = target;
    this.candidates = candidates;
    res = new ArrayList<List<Integer>>();
    DFS(0, 0, new ArrayList<Integer>());
    return res;
}
public void DFS(int index, int nowSum, List<Integer> list) {
	// 剪枝
    if(nowSum > target) {
        return;
    }
    // 递归出口1
    if(index == candidates.length) {
        return;
    }
    // 递归出口2
    if(nowSum == target) {
        res.add(new ArrayList<Integer>(list));
        return;
    }
    // 选择 candidates[index]
    list.add(candidates[index]);
    DFS(index, nowSum + candidates[index], list);
    list.remove(list.size() - 1);
    // 不选择candidates[index]
    DFS(index + 1, nowSum, list);
        
 }

例题2

剑指 Offer II 083. 没有重复元素集合的全排列

给定一个不含重复数字的整数数组 nums ，返回其 所有可能的全排列 。可以 按任意顺序 返回答案。

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

这一题是求全排列，就不能上面的思路一，因为对于任意一个位置的元素，并不是在选择 or 不选择中做出抉择，而是将该元素放置到哪里，这种时候就该按照思路二去思考，即：每次调用DFS( )都是在往某一条递归路径形成的集合中加入第n个数，n代表DFS( )调用栈的深度
基本过程是，先选择第一个数，这个数应该是从所有还没选择过的数中任意选择一个，之后调用DFS()进入递归的下一层，确定第2个数，然后依次递归下去直到确认完第nums.length个数，过程中用visit[i]数组记录nums[i]是否被使用过；

这里的递归出口是确认完第nums.length个数时递归返回

class Solution {
    int[] nums;
    List<List<Integer>> res;
    boolean[] visit;
    public List<List<Integer>> permute(int[] nums) {
        res = new ArrayList<List<Integer>>();
        this.nums = nums;
        visit = new boolean[nums.length];
        DFS(new ArrayList<Integer>());
        return res;
    }
    public void DFS(List<Integer> list) {

        if(list.size() == nums.length) {
            res.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i = 0; i < nums.length; ++i) {
            if(visit[i]) {
                continue;
            }
            visit[i] = true;
            list.add(nums[i]);
            DFS(list);
            list.remove(list.size() - 1);
            visit[i] = !visit[i];
        }
    }
}

整个递归回溯的过程可以如下图示意：

基于思路2往往可以解决一些更为复杂一些的回溯问题，比如全排列中去除重复集合(所含元素种类，每个种类个数完全一样的集合)，去重的本质就是在递归路径集合选择第n个数时，由于会在所有还未选择的数中选择一个，这些数中可能会有重复的值，此时不要选择重复值即可