Java实现回溯算法入门（排列+组合+子集）

算法相关数据结构总结：

序号	数据结构	文章
1	动态规划	动态规划之背包问题——01背包 动态规划之背包问题——完全背包 动态规划之打家劫舍系列问题 动态规划之股票买卖系列问题 动态规划之子序列问题 算法（Java）——动态规划
2	数组	算法分析之数组问题
3	链表	算法分析之链表问题 算法（Java）——链表
4	二叉树	算法分析之二叉树 算法分析之二叉树遍历 算法分析之二叉树常见问题 算法（Java）——二叉树
5	哈希表	算法分析之哈希表 算法（Java）——HashMap、HashSet、ArrayList
6	字符串	算法分析之字符串 算法（Java）——字符串String
7	栈和队列	算法分析之栈和队列 算法（Java）——栈、队列、堆
8	贪心算法	算法分析之贪心算法
9	回溯	Java实现回溯算法入门（排列+组合+子集） Java实现回溯算法进阶（搜索）
10	二分查找	算法（Java）——二分法查找
11	双指针、滑动窗口	算法（Java）——双指针 算法分析之滑动窗口类问题

回溯是递归的副产品，只要有递归就会有回溯，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。

回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况：

1. 找到一个可能存在的正确的答案；
2. 在尝试了所有可能的分步方法后宣告该问题没有答案。

回溯法就是暴力搜索，并不是什么高效的算法，最多再剪枝一下。

回溯算法能解决如下问题：

1. 组合问题：N个数里面按一定规则找出k个数的集合
2. 排列问题：N个数按一定规则全排列，有几种排列方式
3. 切割问题：一个字符串按一定规则有几种切割方式
4. 子集问题：一个N个数的集合里有多少符合条件的子集
5. 棋盘问题：N皇后，解数独等等

用回溯三部曲来分析回溯算法，回溯法的模板：

void backtracking(参数){
   
    if(终止条件){
   
        存放结果;
        return;
    }
    for(选择：本层集合中元素（树中节点孩子的数量就是集合的大小）){
   
        处理节点;
        backtracking(路径，选择列表);
        回溯，撤销处理结果;
    }
}

1. 从全排列问题开始理解回溯算法

我们尝试在纸上写 3 个数字、4 个数字、5 个数字的全排列，相信不难找到这样的方法。以数组 [1, 2, 3] 的全排列为例。

1. 先写以 1 开头的全排列，它们是：[1, 2, 3], [1, 3, 2]，即 1 + [2, 3] 的全排列（注意：递归结构体现在这里）；
2. 再写以 2 开头的全排列，它们是：[2, 1, 3], [2, 3, 1]，即 2 + [1, 3] 的全排列；
3. 最后写以 3 开头的全排列，它们是：[3, 1, 2], [3, 2, 1]，即 3 + [1, 2] 的全排列。

总结搜索的方法：**按顺序枚举每一位可能出现的情况，已经选择的数字在 当前 要选择的数字中不能出现。**按照这种策略搜索就能够做到 不重不漏。这样的思路，可以用一个树形结构表示。

看到这里的朋友，建议先尝试自己画出「全排列」问题的树形结构。

说明：

1. 每一个结点表示了求解全排列问题的不同的阶段，这些阶段通过变量的「不同的值」体现，这些变量的不同的值，称之为「状态」；
2. 使用深度优先遍历有「回头」的过程，在「回头」以后， 状态变量需要设置成为和先前一样 ，因此在回到上一层结点的过程中，需要撤销上一次的选择，这个操作称之为「状态重置」；
3. 深度优先遍历，借助系统栈空间，保存所需要的状态变量，在编码中只需要注意遍历到相应的结点的时候，状态变量的值是正确的，具体的做法是：往下走一层的时候，path 变量在尾部追加，而往回走的时候，需要撤销上一次的选择，也是在尾部操作，因此 path 变量是一个栈；
4. 深度优先遍历通过「回溯」操作，实现了全局使用一份状态变量的效果。

使用编程的方法得到全排列，就是在这样的一个树形结构中完成 遍历，从树的根结点到叶子结点形成的路径就是其中一个全排列。

设计状态变量

1. 首先这棵树除了根结点和叶子结点以外，每一个结点做的事情其实是一样的，即：在已经选择了一些数的前提下，在剩下的还没有选择的数中，依次选择一个数，这显然是一个 递归 结构；
2. 递归的终止条件是： 一个排列中的数字已经选够了 ，因此我们需要一个变量来表示当前程序递归到第几层，我们把这个变量叫做 depth，或者命名为 index ，表示当前要确定的是某个全排列中下标为 index 的那个数是多少；
3. 布尔数组 used，初始化的时候都为 false 表示这些数还没有被选择，当我们选定一个数的时候，就将这个数组的相应位置设置为 true ，这样在考虑下一个位置的时候，就能够以 O(1)的时间复杂度判断这个数是否被选择过，这是一种「以空间换时间」的思想。

这些变量称为「状态变量」，它们表示了在求解一个问题的时候所处的阶段。需要根据问题的场景设计合适的状态变量。

46.全排列

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

示例一：

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

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

代码实现：

class Solution {
   
    public List<List<Integer>> permute(int[] nums) {
   
        List<List<Integer>> res = new ArrayList<>();
        if(nums.length == 0){
   
            return res;
        }
        Deque<Integer> path = new ArrayDeque<>(); // 用栈去构造path,存储已经选了哪些数
        boolean[] used = new boolean[nums.length];  // 用一个used数组判断是否被用过
        dfs(nums, 0, path, used, res); // 递归每一层
        return res;
    }
    private void dfs(int[] nums, int depth, Deque<Integer> path, boolean[] used, List<List<Integer>> res){
   
        if(depth == nums.length){
     // 当遍历的层数等于数组长度时结束
            res.add(new ArrayList<>(path)); // 将path的拷贝加入到res中，就不会出现多余的空列表，要注意
            return;
        }
        for(int i = 0; i < nums.length; i++){
   
            if(used[i]){
   
                continue;  // 如果使用过，则跳出
            }
            path.addLast(nums[i]);
            used[i] = true;
            dfs(nums, depth+1, path, used, res); // 遍历下一层
            path.removeLast(); //回溯，回到上一层结点
            used[i] = false;
        }
    }
}

说明：

状态变量：

1. depth，递归到第几层，这里就是数组的长度。
2. path，已经选了哪些数，需要回溯撤销，所以用栈实现，Java中推荐使用Deque构建栈。
3. used，布尔数组，判断哪些选择过了。

还需要注意的一点是：

if(depth == nums.length){
     // 当遍历的层数等于数组长度时结束
    res.add(new ArrayList<>(path)); // 将path的拷贝加入到res中，就不会出现多余的空列表，要注意
    return;
}

如果直接将path加入到res中，就会出现错误：

if (depth == len) {
   
    res.add(path);
    return;
}

变量 path 所指向的列表 在深度优先遍历的过程中只有一份 ，深度优先遍历完成以后，回到了根结点，成为空列表。

在 Java 中，参数传递是 值传递，对象类型变量在传参的过程中，复制的是变量的地址。这些地址被添加到 res 变量，但实际上指向的是同一块内存地址，因此我们会看到空的列表对象。解决的方法很简单，在 res.add(path); 这里做一次拷贝即可。

47.全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复