代码随想录算法训练营第二十九天 | 491. 递增子序列，46. 全排列，47. 全排列II

491. 递增子序列

本题和大家刚做过的 90.子集II 非常像，但又很不一样，很容易掉坑里。 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法精讲，树层去重与树枝去重 | LeetCode：491.递增子序列_哔哩哔哩_bilibili

重点：

1. 树层去重：Set记录本层使用过的元素

2. 裁剪树枝： 如果当前元素比path的最后一个元素还要小，没必要处理

思路：

递归+回溯：

1. 确定参数及返回值

private void backtracking(int[] nums, int startIndex)

2. 确定终止条件

求子集问题的终止条件其实都没必要写，因为for循环会自动终止

if (startIndex >= nums.length) { return; }

3. 确定单层递归的逻辑

levelRecords不用回溯是因为这个是需要记录本层元素是否重复使用的，如果回溯了的话，那么根本记录不了，而且levelRecords也是只负责本层的，每一层都有自己独自的levelRecords

Set<Integer> levelRecords = new HashSet<>();
for (int i = startIndex; i < nums.length; i++) {
    if (!path.isEmpty() && nums[i] < path.get(path.size() - 1)
            || levelRecords.contains(nums[i])) {
        continue;
    }
    levelRecords.add(nums[i]);
    path.add(nums[i]);
    backtracking(nums, i + 1);
    path.remove(path.size() - 1);
}

List<Integer> path;
List<List<Integer>> result;
public List<List<Integer>> findSubsequences(int[] nums) {
    path = new ArrayList<>();
    result = new ArrayList<>();
    backtracking(nums, 0);
    return result;
}

private void backtracking(int[] nums, int startIndex) {
    // 只有2个及以上元素才会收集
    if (path.size() > 1) {
        result.add(new ArrayList<>(path));
    }
    if (startIndex >= nums.length) {
        return;
    }
    // 用来记录本层使用过的元素，避免重复使用，不需要进行回溯
    Set<Integer> levelRecords = new HashSet<>();
    for (int i = startIndex; i < nums.length; i++) {
        if (!path.isEmpty() && nums[i] < path.get(path.size() - 1)
                || levelRecords.contains(nums[i])) {
            continue;
        }
        levelRecords.add(nums[i]);
        path.add(nums[i]);
        backtracking(nums, i + 1);
        path.remove(path.size() - 1);
    }
}

46. 全排列

本题重点感受一下，排列问题 与 组合问题，组合总和，子集问题的区别。 为什么排列问题不用 startIndex

题目链接/文章讲解： 代码随想录

视频讲解： 组合与排列的区别，回溯算法求解的时候，有何不同？| LeetCode：46.全排列_哔哩哔哩_bilibili

重点：

1. 与组合不同，排列不需要去重，所以不需要用startIndex来达到去重的目的

2. used数组来帮助我们continue用过的元素

思路：

递归+回溯：

1. 确定参数及返回值

private void backtracking(int[] nums, boolean[] used)

2. 确定终止条件

排列所有结果的长度都跟nums的长度一致

if (path.size() == nums.length) {
    result.add(new ArrayList<>(path));
    return;
}

3. 确定单层递归的逻辑

与组合不同，不需要用到startIndex来去重，每次都要从0开始，遇到用过的元素就跳过

for (int i = 0; i < nums.length; i++) {
    // 遇到用过的元素直接跳过
    if (used[i] == true) {
         continue;
    }
    path.add(nums[i]);
    used[i] = true;
    backtracking(nums, used);
    // 用完之后回溯回false
    used[i] = false;
    path.remove(path.size() - 1);
}

List<Integer> path;
List<List<Integer>> result;
public List<List<Integer>> permute(int[] nums) {
    path = new ArrayList<>();
    result = new ArrayList<>();
    boolean[] used = new boolean[nums.length];
    backtracking(nums, used);
    return result;
}

private void backtracking(int[] nums, boolean[] used) {
    if (path.size() == nums.length) {
        result.add(new ArrayList<>(path));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        // 遇到用过的元素直接跳过
        if (used[i] == true) {
             continue;
        }
        path.add(nums[i]);
        used[i] = true;
        backtracking(nums, used);
        // 用完之后回溯回false
        used[i] = false;
        path.remove(path.size() - 1);
    }
}

47. 全排列II

本题 就是我们讲过的 40.组合总和II 去重逻辑 和 46.全排列 的结合，可以先自己做一下，然后重点看一下 文章中 我讲的拓展内容。 used[i - 1] == true 也行，used[i - 1] == false 也行

题目链接/文章讲解：代码随想录

视频讲解： 回溯算法求解全排列，如何去重？| LeetCode：47.全排列 II_哔哩哔哩_bilibili

重点：

1. 利用used数组树层去重

2. 利用used数组跳过已经使用过的元素

3. 本题树枝去重（used[i - 1] == true）也可以做，但是去重效率会低很多

思路：

递归+回溯：

1. 确定参数及返回值

private void backtracking(int[] nums, boolean[] used)

2. 确定终止条件

if (path.size() == nums.length) {
    result.add(new ArrayList<>(path));
    return;
}

3. 确定单层递归的逻辑

for (int i = 0; i < nums.length; i++) {
    // 跳过使用过的元素 或者 树层上重复的元素
    if (used[i] == true ||
            (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)) {
        continue;
    }
    path.add(nums[i]);
    used[i] = true;
    backtracking(nums, used);
    used[i] = false;
    path.remove(path.size() - 1);
}

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

private void backtracking(int[] nums, boolean[] used) {
    if (path.size() == nums.length) {
        result.add(new ArrayList<>(path));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        // 跳过使用过的元素 或者 树层上重复的元素
        if (used[i] == true ||
                (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)) {
            continue;
        }
        path.add(nums[i]);
        used[i] = true;
        backtracking(nums, used);
        used[i] = false;
        path.remove(path.size() - 1);
    }
}