【代码随想录训练营】Day29-回溯算法

代码随想录训练营 Day29

今日任务

491.递增子序列
46.全排列
47.全排列Ⅱ
语言：Java

491. 递增子序列

链接：https://leetcode.cn/problems/increasing-subsequences/

踩坑记录：

1. 本题要求返回递增子序列，还不能重复，显然不可以先进行排序再去重，而要通过used数组的方式来去重；因为去重是在同一层中去重，所以要在每一次回溯的时候新建一个当层的used数组；
2. 去重去的是同一层中相同的值，所以要通过哈希数组的方式记录元素使用情况；
3. 在判断是否是递增数组时不可以通过nums[i] < nums[i - 1]这种方式，因为子序列中的元素在nums中不一定是相邻的，要用nums[i] < subsequence.get(subsequence.size() - 1)这种方式判断；
4. used数组的赋值一定要在if条件判断后，否则会略过还没使用过的值。

class Solution {
    List<List<Integer>> result;
    List<Integer> subsequence;
    //1.int[] used;
    public void backTracking(int[] nums, int startIdx){
        if(subsequence.size() >= 2){
            result.add(new ArrayList(subsequence));
        }
        int[] used = new int[201]; //1.在每一层中记录使用情况
        for(int i = startIdx; i < nums.length; i++){
            //used[nums[i] + 100] = 1; //4.
            //3.
            if(!subsequence.isEmpty() && nums[i] < subsequence.get(subsequence.size() - 1) || used[nums[i] + 100] == 1){
                continue;
            }
            used[nums[i] + 100] = 1;
            subsequence.add(nums[i]);
            backTracking(nums, i + 1);
            subsequence.remove(subsequence.size() - 1);
        }
    }
    public List<List<Integer>> findSubsequences(int[] nums) {
        result = new ArrayList<List<Integer>>();
        subsequence = new ArrayList<Integer>();
        //1.used = new int[201];
        backTracking(nums, 0);
        return result;
    }
}

46. 全排列

链接：https://leetcode.cn/problems/permutations/

class Solution {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> subset = new ArrayList<Integer>();
    int[] used = new int[21];
    //distinct integers
    public void backTracking(int[] nums){
        if(subset.size() == nums.length){
            result.add(new ArrayList(subset));
            return;
        }
        for(int i = 0; i < nums.length; i++){
            if(used[nums[i] + 10] == 1){
                continue;
            }
            used[nums[i] + 10] = 1;
            subset.add(nums[i]);
            backTracking(nums);
            used[nums[i] + 10] = 0;
            subset.remove(subset.size() - 1);
        }
    }
    public List<List<Integer>> permute(int[] nums) {
        backTracking(nums);
        return result;
    }
}

47. 全排列Ⅱ

链接：https://leetcode.cn/problems/permutations-ii/

改进：卡哥代码

1. 先对数组进行排序，只用一个数组记录树层和树枝上元素的使用情况，false代表同一层上使用过。最开始的时候所有元素处于通一层，used中都是false，后来随着回溯进入下一层/回到上一层，used的值在不断变化，进入下一层就是true，回到上一层又变为false；
2. 在排列问题中，对树层去重和对树枝去重都是可以的，但对树层去重效率更高，对树枝去重会多很多不必要的搜索操作。

class Solution {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> permute = new ArrayList<Integer>();
    int[] record = new int[8]; //记录不同层
    public void backTracking(int[] nums){
        if(permute.size() == nums.length){
            result.add(new ArrayList(permute));
            return;
        }
        int[] used = new int[21]; //记录同一层
        for(int i = 0; i < nums.length; i++){
            if(used[nums[i] + 10] == 1 || record[i] == 1){
                continue;
            }
            used[nums[i] + 10] = 1;
            permute.add(nums[i]);
            record[i] = 1;
            backTracking(nums);
            record[i] = 0;
            permute.remove(permute.size() - 1);
        }
    }
    public List<List<Integer>> permuteUnique(int[] nums) {
        backTracking(nums);
        return result;
    }
}