代码随想录训练营第二十五天 | 491.递增子序列 46.全排列 47.全排列 II 332.重新安排行程（可跳过）51.N皇后（适当跳过）37.解数独（适当跳过） 总结

491.递增子序列

candidates有重复，但不能排序。

自己的写法：不能排序，就不能用used数组。只能用set。
但是成员变量set……不行。

这里的剪枝是要剪去本层的枝，所以是在for循环中剪。每层都需要独立的set。并且不需回溯。

// 错误解法
class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        // 不能排序，就不能用used数组。
        set = new HashSet<>();
        backTracking(nums, 0);
        return result;
    }

    private List<List<Integer>> result;
    private LinkedList<Integer> path;
    private Set<Integer> set;
    private void backTracking(int[] nums, int startIndex){ // 不仅叶子节点
        if(path.size()>1) result.add(new ArrayList<Integer>(path));
        set.clear();
        for(int i=startIndex; i<nums.length; i++){
            if(!path.isEmpty() && nums[i] < path.getLast() || set.contains(nums[i])) continue;
            set.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums, i+1);
            path.removeLast();

        }
    }
}

代码随想录解法：

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return result;
    }
    private void backTracking(int[] nums, int startIndex){
        if(path.size() >= 2)
                result.add(new ArrayList<>(path));            
        HashSet<Integer> hs = new HashSet<>();
        for(int i = startIndex; i < nums.length; i++){
            if(!path.isEmpty() && path.get(path.size() -1 ) > nums[i] || hs.contains(nums[i]))
                continue;
            hs.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

46.全排列

candidates不包含重复数字。

这里的剪枝剪得是同树枝的枝，因此used数组需要是成员变量，而不是每层各一个。

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        used = new boolean[nums.length];
        Arrays.fill(used, false);
        backTracking(nums);
        return result;
    }

    private List<List<Integer>> result;
    private LinkedList<Integer> path;
    private boolean[] used;
    private void backTracking(int[] nums){
        if(path.size()==nums.length){
            result.add(new ArrayList<>(path));
            return;
        }

        for(int i=0; i<used.length; i++){
            if(used[i]) continue; // 同树枝使用过
            used[i] = true;
            path.add(nums[i]);
            backTracking(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

47.全排列 II （难）

candidates包含重复数字。

1. used：用于同层剪枝。因此每层有一个新的、不用回溯。
2. used2：用于同枝剪枝。因此成员变量、需要回溯。

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) { // 排列问题，而非组合问题：结果的去重与顺序有无关系
        result = new ArrayList<>();
        path = new LinkedList<>();
        used2 = new boolean[nums.length];
        Arrays.fill(used2, false);
        backTracking(nums);
        return result;
    }

    private List<List<Integer>> result;
    private LinkedList<Integer> path;
    private boolean[] used2;

    private void backTracking(int[] nums){
        if(path.size()==nums.length){
            result.add(new ArrayList<Integer>(path));
            return;
        }
        // 观察示例，需要同层的剪枝：该位置不能重复
        boolean[] used = new boolean[21];
        for(int i=0; i<nums.length; i++){ // 排列问题去重不需要startIndex，而用used？
            if(used2[i]) continue;
            if(used[nums[i]+10]) continue;
            used2[i] = true;
            used[nums[i]+10] = true;
            path.add(nums[i]);
            backTracking(nums);
            path.removeLast();
            used2[i] = false;
        }
    }
}

代码随想录解法：

1. 同层剪枝、同枝剪枝都用一套used数组。但是前提是需要对nums排序。

class Solution {
    //存放结果
    List<List<Integer>> result = new ArrayList<>();
    //暂存结果
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        Arrays.sort(nums);
        backTrack(nums, used);
        return result;
    }

    private void backTrack(int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            // used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过
            // used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //如果同⼀树⽀nums[i]没使⽤过开始处理
            if (used[i] == false) {
                used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用
                path.add(nums[i]);
                backTrack(nums, used);
                path.remove(path.size() - 1);//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;//回溯
            }
        }
    }
}

332.重新安排行程（可跳过）

51.N皇后（适当跳过）

37.解数独（适当跳过）

总结

---

问题：

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

组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

---

模板：

1. 类似深度优先搜索，一个一个枝的深度搜索。
2. for的每一次循环，就是一个枝搜索到底了—— for 循环横向遍历，递归纵向遍历，回溯不断调整结果集。
3. 同层剪枝：剪枝精髓是，for循环在寻找起点的时候要有一个范围……

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

---

startIndex 对于组合问题：每取一个元素，会不会对candidates有影响。

• 有影响：抽取组合 —— 有影响的才会需要index（需要去重）、需要剪枝
• 无影响：电话号码对应字母 （有多组candidates，每个数字对应一组candidates，并且取元素不会对其有影响）

---

used数组与去重：candidates有重复的，此时要进行树层去重。
在candidates[i] == candidates[i - 1]相同的情况下：（当然前提是已经排序）

• used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
• used[i - 1] == false，说明同一树层candidates[i - 1]使用过

---

切割问题：避免重复切割，需要index

• 对于切割线之前的元素进行选中。

---

子集问题：遍历所有节点，不仅仅是叶子。

• 去重：used数组

---

排列问题：

• 排列不需要startIndex，而是需要used：没取过的元素，回头还要取。

---