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

---

491.递增子序列

教程视频：https://www.bilibili.com/video/BV1EG4y1h78v/?vd_source=ddffd51aa532d23e6feac69924e20891
本题的难点是不能排序，因此我们不能像90、子集II那样直接采用used数组记录使用情况，而应该采用map记录path中已经包含的数字进行数层去重。针对本题，因为nums中的数据范围有限，可以使用数组索引对应每一种数值来进行树层去重。

解法一：回溯（map进行数层去重）

//用map去重
class Solution {
    //结果集合
    List<List<Integer>> res = new ArrayList<>();
    //路径集合
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        getSubsequences(nums,0);
        return res;
    }
    private void getSubsequences( int[] nums, int start ) {
        if(path.size()>1 ){
            res.add( new ArrayList<>(path) );
            // 注意这里不要加return，要取树上的节点
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i=start ;i < nums.length ;i++){
            if(!path.isEmpty() && nums[i]< path.getLast()){
                continue;
            }
            // 使用过了当前数字
            if ( map.getOrDefault( nums[i],0 ) >=1 ){
                continue;
            }
            map.put(nums[i],map.getOrDefault( nums[i],0 )+1);
            path.add( nums[i] );
            getSubsequences( nums,i+1 );
            path.removeLast();
        }
    }
}

//用set去重
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;
    }

    
    public void backtracking(int[] nums, int startIndex){
        if(path.size()>1){
            result.add(new ArrayList<>(path));
        }
        //求子集可以不写终止条件
        if(startIndex>=nums.length){
            return;
        }

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

解法二：回溯（仅针对本题，不具有普适性）

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;
    }
    
    public void backtracking(int[] nums, int startIndex){
        if(path.size()>1){
            result.add(new ArrayList<>(path));
        }
        
        int[] used = new int[201];
        for(int i=startIndex;i<nums.length;i++){
            //前半部分是去除非递增子串，后半部分数层去重
            if((!path.isEmpty() && path.get(path.size()-1)>nums[i]) || (used[nums[i]+100]==1)){continue;}
            used[nums[i]+100]=1;
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

---

46.全排列

教程视频：https://www.bilibili.com/video/BV19v4y1S79W/?spm_id_from=333.788&vd_source=ddffd51aa532d23e6feac69924e20891

这是排列问题，有两个需要关注的点：1、每层都是从0开始搜索而不是startIndex；2、需要记录path里都放了哪些元素了。

解法一：回溯（used数组记录去重，不是树层去重）

因为每层used要在上一层的基础上修改，因此used需要作为回溯参数传递。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permute(int[] 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++){
            if(used[i]){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.remove(path.size()-1);
        }
    }
}

解法二：回溯（根据path中是否含有该元素去重）

针对本题nums中数值互不相同，可以根据path中是否含有该元素去重

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return result;
    }
    public void backtracking(int[] nums){
        if(path.size()==nums.length){
            result.add(new ArrayList<>(path));
            return;
        }

        for(int i=0;i<nums.length;i++){
            if(path.contains(nums[i])){
                continue;
            }
            path.add(nums[i]);
            backtracking(nums);
            path.remove(path.size()-1);
        }
    }
}

---

47.全排列 II

教程视频：https://www.bilibili.com/video/BV1R84y1i7Tm/?spm_id_from=pageDriver&vd_source=ddffd51aa532d23e6feac69924e20891

解法一：回溯

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    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]控制在同一层去重
            if(i>0 && nums[i-1]==nums[i] && !used[i-1]){
                continue;
            }
            if(used[i]){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.remove(path.size()-1);
        }
    }
}

总结

1、不能排序时，需要采用Map进行树层去重。同时，求子集可以省略终止条件。
2、排列问题，有两个需要关注的点：a、每层都是从0开始搜索而不是startIndex；b、需要记录path里都放了哪些元素了。
3、47.全排列 II 是46.全排列和40.组合总和II的结合。树枝不去重，树层去重。