重生之我在代码随想录刷算法第二十二天 | 491.递增子序列、46.全排列、 47.全排列 II

参考文献链接：代码随想录

本人代码是Java版本的，如有别的版本需要请上代码随想录网站查看。

491.递增子序列

力扣题目链接

解题思路

这道题目跟昨天求子集的差不多，只需要在for循环中paths添加元素前判断一下是否递增即可。

但这里的去重逻辑和以往不同，以往我们用used数组判断的是当前元素和上一个元素是否相同。

去重

比如4，7，6，7这一组。

首先你选择了4，然后你选择第一个7和第二个7的结果是一样所以要去重，但是不能用used了，因为他俩根本没相邻。

所以要用一个Set集合去重。

代码示例

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

    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums,0);
        return result;

    }
    public void backtracking(int[] nums,int start){
        if(paths.size() > 1){
            result.add(new ArrayList<>(paths));
        }
        if(start == nums.length){
            return;
        }
        HashSet<Integer> hs = new HashSet<>();
        for(int i = start;i < nums.length;i++){
            if(paths.size() > 0 && paths.get(paths.size() - 1) > nums[i] || hs.contains(nums[i])){
                continue;
            }
            hs.add(nums[i]);
            paths.add(nums[i]);
            backtracking(nums,i + 1);
            paths.remove(paths.size() - 1);
        }
    }
}

46.全排列

力扣题目链接

解题思路

这道题目只要理解与组合的差异还是比较好做的，他就是要把所有元素排列，所以我们的终止条件就是收集到所有的元素即可。

还有一个注意的是我们不能收集到同一个元素，这就很好判断了，只需每次判断paths里不包含这个元素再加入即可。

代码示例

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

    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return result;
    }
    public void backtracking(int[] nums){
        if(paths.size() == nums.length){
            result.add(new ArrayList<>(paths));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(paths.contains(nums[i])){
                continue;
            }
            paths.add(nums[i]);
            backtracking(nums);
            paths.remove(paths.size() - 1);
        }
    }
}

47.全排列 II

力扣题目链接(https://leetcode.cn/problems/subsets-ii/)

解题思路

这道题与上一题区别是数组中有重复的元素，那我们就要多一次去重，也就是树枝上也要判断某一个元素是否使用过。

if(used[i] == false){
         used[i] = true;
         paths.add(nums[i]);
         backtracking(nums);
         used[i] = false;
         paths.remove(paths.size() - 1);
}

之前我们的used是用来判断树层之间是否重复使用，是害怕使用同一元素遍历两次，但这次是害怕使用同一个重复数字的元素两次。

代码示例

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> paths = new ArrayList<>();
    boolean[] used;

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.fill(used,false);
        Arrays.sort(nums);
        backtracking(nums);
        return result;
    }
    public void backtracking(int[] nums){
        if(paths.size() == nums.length){
            result.add(new ArrayList<>(paths));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false){
                continue;
            }
            if(used[i] == false){
                used[i] = true;
                paths.add(nums[i]);
                backtracking(nums);
                used[i] = false;
                paths.remove(paths.size() - 1);
            }
        }
    }
}