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

491.递增子序列 

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

https://programmercarl.com/0491.%E9%80%92%E5%A2%9E%E5%AD%90%E5%BA%8F%E5%88%97.html

视频讲解：https://www.bilibili.com/video/BV1EG4y1h78v

//结果集合
    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();
        }
    }

46.全排列 

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

https://programmercarl.com/0046.%E5%85%A8%E6%8E%92%E5%88%97.html

视频讲解：https://www.bilibili.com/video/BV19v4y1S79W

List<List<Integer>> ans = new ArrayList<>();
    LinkedList<Integer> res = new LinkedList<>();
   public List<List<Integer>> permute(int[] nums) {
        dfs(nums);
        return ans;
    }

    public void dfs (int[] nums){
        if(res.size() == nums.length){
            ans.add(new ArrayList<>(res));
            return;
        }
        for(int i =0 ; i< nums.length;i++){
             if (res.contains(nums[i])) {
                continue;
            } 
            res.add(nums[i]);
            dfs(nums);
            res.removeLast();
        }

    }

47.全排列 II 

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

https://programmercarl.com/0047.%E5%85%A8%E6%8E%92%E5%88%97II.html

视频讲解：https://www.bilibili.com/video/BV1R84y1i7Tm

List<List<Integer>> ans = new ArrayList<>();
    LinkedList<Integer> res = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.fill(used, false);
        Arrays.sort(nums);
        dfs(nums);
        return ans;
    }

    public void dfs (int[] nums){
        if(res.size() == nums.length){
            ans.add(new ArrayList<>(res));
            return;
        }
        for(int i =0 ; i< nums.length;i++){
           if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //如果同⼀树⽀nums[i]没使⽤过开始处理
            if (used[i] == false) {
                used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用
                res.add(nums[i]);
                dfs(nums);
                res.removeLast();//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;//回溯
            }

    }

}