力扣刷题：DFS题型：排列，组合问题

注：看每道题后面的参考连接，大神写的特别好。

这一类问题都需要先画出树形图，然后编码实现。编码通过 深度优先遍历 实现，使用一个列表，在 深度优先遍历 变化的过程中，遍历所有可能的列表并判断当前列表是否符合题目的要求，成为「回溯算法」。

 

46. 全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

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

以数组 [1, 2, 3] 的全排列为例。

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

按顺序枚举每一位可能出现的情况，已经选择的数字在 当前 要选择的数字中不能出现。按照这种策略搜索就能够做到 不重不漏。

设计状态变量

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

class Solution {
    public List> permute(int[] nums) {
        /*
        定义状态变量：
        1.depth:递归到第几层
        2.path:已经选了哪些数
        3.used:布尔数组，这个数是否已经使用
        */
        List> res = new ArrayList<>();
        //输入数组长度
        int len = nums.length;
        if(len == 0){
            return res;
        }
        Deque path = new ArrayDeque<>();
        boolean[] used = new boolean[len];
        //dfs(输入数组，输入数组长度,当前一共选择了几个数（初始化为0）,从根节点到任意节点列表(这是一个栈)，布尔数组，最终结果)
        dfs(nums, len, 0, path, used, res);
        return res;
    }
    private void dfs(int[] nums, int len, int depth, Deque path, boolean[] used, List> res){
        //递归终止条件，层数=输入数组大小
        if(depth == len){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i=0;i

参考：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-python-dai-ma-java-dai-ma-by-liweiw/

47. 全排列 II

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

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

对比图中标注 ① 和 ② 的地方。

• 相同点是：这一次搜索的起点和上一次搜索的起点一样。
• 不同点是：
  • 标注 ① 的地方上一次搜索的相同的数刚刚被撤销；
  • 标注 ② 的地方上一次搜索的相同的数刚刚被使用。

class Solution {
    public List> permuteUnique(int[] nums) {
        int len = nums.length;
        List> res = new ArrayList<>();
        if(len == 0){
            return res;
        }
        // 排序（升序或者降序都可以），排序是剪枝的前提
        Arrays.sort(nums);
        boolean[] used = new boolean[len];
        // 使用 Deque 是 Java 官方 Stack 类的建议
        Deque path = new ArrayDeque<>(len);
        dfs(nums, len, 0, used, path, res);
        return res;
    }
    private void dfs(int[] nums, int len, int depth, boolean[] used, Deque path, List> res){
        if(depth == len){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i 0 是为了保证 nums[i - 1] 有意义
            // 写 !used[i - 1] 是因为 nums[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
            if(i>0 && nums[i] == nums[i-1] && used[i-1] == false){
                continue;
            }

            path.addLast(nums[i]);
            used[i] = true;
            dfs(nums, len, depth+1, used, path, res);
            // 回溯部分的代码，和 dfs 之前的代码是对称的
            used[i] = false;
            path.removeLast();

        }
    }
}

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：所有数字（包括 target）都是正整数。解集不能包含重复的组合。 
示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：[ [7],[2,2,3]]

根据示例 1：输入: candidates = [2, 3, 6, 7]，target = 7。

• 候选数组里有 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
• 同理考虑 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。

说明：

• 以 target = 7 为 根结点 ，创建一个分支的时 做减法 ；
• 每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 candidate 数组的每个元素的值；
• 减到 00 或者负数的时候停止，即：结点 00 和负数结点成为叶子结点；(终止条件)
• 所有从根结点到结点 00 的路径（只能从上往下，没有回路）就是题目要找的一个结果。

这棵树有 44 个叶子结点的值 00，对应的路径列表是 [[2, 2, 3], [2, 3, 2], [3, 2, 2], [7]]，而示例中给出的输出只有 [[7], [2, 2, 3]]。即：题目中要求每一个符合要求的解是 不计算顺序 的。

每一次搜索的时候设置 下一轮搜索的起点 begin

剪枝条件：从每一层的第 2个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。

class Solution {
    public List> combinationSum(int[] candidates, int target) {
        int len = candidates.length;
        //这类题总有下面这一句代码
        List> res = new ArrayList<>();
        if(len == 0) return res;

        //排序是剪枝的前提
        Arrays.sort(candidates);
        Deque path = new ArrayDeque<>();
        dfs(candidates, 0, len, target, path, res);
        return res;
    }
    private void dfs(int[] candidates, int begin, int len, int target, Deque path, List> res){
        // 由于进入更深层的时候，小于 0 的部分被剪枝，因此递归终止条件值只判断等于 0 的情况
        if(target == 0){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = begin; i < len; i++){
            // 重点理解这里剪枝，前提是候选数组已经有序
            if(target - candidates[i] < 0){
                break;
            }
            path.addLast(candidates[i]);
            dfs(candidates,i,len,target-candidates[i],path,res);
            path.removeLast();
        }
    }
}

参考：https://leetcode-cn.com/problems/combination-sum/solution/hui-su-suan-fa-jian-zhi-python-dai-ma-java-dai-m-2/

40. 组合总和 II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：所有数字（包括目标数）都是正整数。解集不能包含重复的组合。 
示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:[  [1, 7],  [1, 2, 5],  [2, 6],  [1, 1, 6] ]

这道题与上一问的区别在于：

• 第 39 题：candidates 中的数字可以无限制重复被选取；
• 第 40 题：candidates 中的每个数字在每个组合中只能使用一次。

如上图，剪枝条件是：同一个结点产生的分支，边上减去的数相同的分支，只保留第1个分支。

如5-1=4，看4这个结点，它减了2’，2’’，2’’’，减了3个2，我们把后面两个2进行剪枝。

剪枝发生在：同一层数值相同的结点第 2、3 ... 个结点，因为数值相同的第 1 个结点已经搜索出了包含了这个数值的全部结果

class Solution {
    public List> combinationSum2(int[] candidates, int target) {
        int len = candidates.length;
        List> res = new ArrayList<>();
        if(len == 0){
            return res;
        }
        //关键步骤
        Arrays.sort(candidates);
        Deque path = new ArrayDeque<>(len);
        dfs(candidates, len, 0, target, path, res);
        return res;
    }
    /**
     * @param candidates 候选数组
     * @param len        冗余变量
     * @param begin      从候选数组的 begin 位置开始搜索
     * @param target     表示剩余，这个值一开始等于 target，基于题目中说明的"所有数字（包括目标数）都是正整数"这个条件
     * @param path       从根结点到叶子结点的路径
     * @param res
     */
    private void dfs(int[] candidates, int len, int begin, int target, Deque path, List> res) {
        if(target == 0){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=begin; ibegin && candidates[i] == candidates[i-1]){
                continue;
            }
            path.addLast(candidates[i]);
            dfs(candidates, len, i+1, target-candidates[i], path, res);
            path.removeLast();
        }
    }

}

解释语句: if cur > begin and candidates[cur-1] == candidates[cur] 是如何避免重复的。

这个方法最重要的作用是，可以让同一层级，不出现相同的元素。

这个避免重复当思想是在是太重要了。
这个方法最重要的作用是，可以让同一层级，不出现相同的元素。即
                  1
                 / \
                2   2  这种情况不会发生 但是却允许了不同层级之间的重复即：
               /     \
              5       5
                例2
                  1
                 /
                2      这种情况确是允许的
               /
              2  
                
为何会有这种神奇的效果呢？
首先 cur-1 == cur 是用于判定当前元素是否和之前元素相同的语句。这个语句就能砍掉例1。
可是问题来了，如果把所有当前与之前一个元素相同的都砍掉，那么例二的情况也会消失。 
因为当第二个2出现的时候，他就和前一个2相同了。
                
那么如何保留例2呢？
那么就用cur > begin 来避免这种情况，你发现例1中的两个2是处在同一个层级上的，
例2的两个2是处在不同层级上的。
在一个for循环中，所有被遍历到的数都是属于一个层级的。我们要让一个层级中，
必须出现且只出现一个2，那么就放过第一个出现重复的2，但不放过后面出现的2。
第一个出现的2的特点就是 cur == begin. 第二个出现的2 特点是cur > begin.

参考：https://leetcode-cn.com/problems/combination-sum-ii/solution/hui-su-suan-fa-jian-zhi-python-dai-ma-java-dai-m-3/

 

针对上面说的去重，做了15题

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：给定数组 nums = [-1, 0, 1, 2, -1, -4]，满足要求的三元组集合为：[  [-1, 0, 1],  [-1, -1, 2] ]

class Solution {
    public List> threeSum(int[] nums) {
        int len = nums.length;
        List> res = new ArrayList<>();
        Arrays.sort(nums);
        for(int k=0; k 0) break;
            //去重
            if(k>0 && nums[k] == nums[k-1]) continue;
            int i=k+1, j=len-1;
            while(i0){
                    while(i(Arrays.asList(nums[k],nums[i],nums[j])));
                    while(i

参考：https://leetcode-cn.com/problems/3sum/solution/3sumpai-xu-shuang-zhi-zhen-yi-dong-by-jyd/

这里感慨一下：大佬真的666！思路清晰，代码写得这么好。中等题好难呀......只能接着刷题了，连续几天刷题了，感觉自己成长了一点点。