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

LeetCode 491.递增子序列

本题需要注意以下几点：

1.题目中要求的递增子序列是在原数组的基础上，不能对原数组进行排序，否则求出来的子序列都是递增的，和leetcode90题就没有区别了；

2.如何对子序列去重，和之前的回溯一样，需要用到startIndex来控制下一次循环的起始位置，此外，对于同一层的元素，如果访问过了则不能再加入子序列，这里可以用哈希表进行处理。

代码如下：（上述两个坑都踩了一遍）

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums,0);
        return result;
    }
    public 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.size() != 0 && path.get(path.size()-1) > nums[i] || hs.contains(nums[i])){
                continue;
            }
            // 满足要求，将访问过的元素加入hashset
            hs.add(nums[i]);
            path.add(nums[i]);
            backtracking(nums, i+1);
            path.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)

LeetCode 46.全排列

全排列问题是大家比较熟悉的数学问题，这里依然采用startIndex来控制每次循环的起始位置，但与之前不同的是，这里的循环每次都需要执行nums.length次，每个数字都要取到，同时取过的元素就不能再取了，所以可以先判断一下nums[i]在不在path中，在的话就continue。代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums,0);
        return result;
    }
    public void backtracking(int[] nums, int start){
        if(path.size() == nums.length){
            result.add(new ArrayList(path));
            return;
        }
        for(int i=start; i-start< nums.length; i++){
            if(path.contains(nums[i%nums.length])) continue;
            path.add(nums[i%nums.length]);
            backtracking(nums, (i+1)%nums.length);
            path.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)

LeetCode 47.全排列 II

本题最开始的思路想要仿照上题，使用start来去重，想避免使用used数组来存储状态，最终发现用start循环数组取数会破坏数组的部分有序，实在是没写出来。看了题解后，发现使用used数组也没想象中那么难，可能之前习惯了使用start所以对相对陌生的used数组有些抗拒。

本题与上题的不同在于数组中会有重复的元素，但我们最后要求的是不重复的全排列，可以用used数组来存储数组元素状态，先对nums数组排序，used[i-1] == false说明同一层i-1使用过，used[i-1] == true说明同一树枝使用过，而明显我们需要处理的是同层去重，即used[i-1] == false，虽然使用used[i-1] == true也同样能做出来，但是树的宽度和深度都会变大，时间花销不划算。代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        backtracking(nums,used);
        return result;
    }
    public 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++){
            // used[i-1] == false说明同一层i-1使用过
            // used[i-1] == true说明同一树枝使用过
            if(i>0 && nums[i] == nums[(i-1)] && used[i-1] == false) continue;
            if(used[i] == false){
                // 未使用过
                used[i] = true;
                path.add(nums[i]);
                backtracking(nums,used);
                path.removeLast();
                used[i] = false;
            }
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)

树层去重，used[i-1] == false时树的情况：

树枝去重，used[i-1] == true时树的情况：