算法刷题｜491.递增子序列、46.全排列、47.全排列||

递增子序列

题目：给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

思路：主要考虑在不能排序的前提下怎么去重复，至于为什么不能排序，因为排序完了之后可能影响结果，例如[4,7,6,7]，排序完之后[4,6,7,7]，将会收集到结果 4 6 7 7但是一开始的数组是不存在4 6 7 7的子序列的。使用一个set集合记录当前递归层的元素是否使用过

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

    private void backtracking(int[] nums,int startIndex,List<Integer> path,List<List<Integer>> res){
        if(path.size() >= 2){
            res.add(new ArrayList<>(path));
        }
        
        // 这里可以不用判断startIndex>=nums.length 然后return，因为即使这里不返回，下面的for循环中会有个i = startIndex;i<nums.length，也会返回

        // 记录每一层递归中使用过的元素
        Set<Integer> used = new HashSet<>();
        for(int i = startIndex;i<nums.length;i++){
            if((path.size() > 0 && nums[i] < path.get(path.size()-1)) || used.contains(nums[i])){
                continue;
            }
            path.add(nums[i]);
            used.add(nums[i]);
            backtracking(nums,i+1,path,res);
            path.remove(path.size() - 1);
            // used是记录每一层递归中的元素是否用过，不存在跨层（跨递归），所有不需要remove
        }
    }
}

全排列

题目：给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

思路：全排列就是所有的元素都要用到，然后组成的集合的不同（包括顺序），排列就不需要使用startIndex了，因为startIndex是防止后续出现的集合和前面的集合是同一个组合，例如[1,2]和[2,1]这两个是一个组合，但是是两个排列，所有本题就不用startIndex了；但是需要一个used数组记录数组元素是否用过，因为排列中的元素是不能够重复的

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        int[] used = new int[nums.length];
        backtracking(nums,path,res,used);
        return res;
    }
    
    private void backtracking(int[] nums,List<Integer> path,List<List<Integer>> res,int[] used){
        // 当收集的结果等于nums的大小的时候就可以收集结果了
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i<nums.length;i++){
            // 如果当前路径结果中使用了当前元素，那么就跳过
            if(used[i] == 1){
                continue;
            }
            path.add(nums[i]);
            used[i] = 1;
            backtracking(nums,path,res,used);
            path.remove(path.size()-1);
            used[i] = 0;
        }
    }
}

全排列||

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

思路：需要在树层上去重，还要在树枝上去重

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

    private void backtracking(int[] nums,List<Integer> path,List<List<Integer>> res,int[] used){
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i<nums.length;i++){
            // 这里是判断树层不能重复 树层去层
            if(i > 0 && nums[i] == nums[i-1] && used[i - 1] == 0){
                continue;
            }

            // 这里是判断path中不能重复，因为每次for循环都是从0开始的所有会重复 树枝去重
            if(used[i] == 0){
                path.add(nums[i]);
                used[i] = 1;
                backtracking(nums,path,res,used);
                path.remove(path.size()-1);
                used[i] = 0;
            }  
        }
    }
}