代码随想录算法训练营|491.递增子序列、46.全排列、47.全排列 II-优快云博客

491.递增子序列

思路：其实这题的思路和前面子集||中的有点相似，但是又有很大不同，这里的元素是不能进行排序的，因为要求的就是递增子序列，所以不能排序，而且还要判断当前组是否是递增的，判断是否是递增就用当前元素是否比path（存的每一个组合）的最后的一个元素大，如果小于就直接跳过当前循环。而hs就是记录当前层中剔除重复元素的，用于去重逻辑中，层递归中出现了同一个元素，第二次遇到就会直接跳过当前循环。注意：这里要取两个及以上的组合来

代码：

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;
    }
    private 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.isEmpty() && path.get(path.size() -1 ) > nums[i] || hs.contains(nums[i]))
                continue;
            hs.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

46.全排列

题目

参考文章

思路：注意：组合和排列是不同的，组合是某两个组合中，如果都是相同元素，但是顺序不同，都属于一个组合；但是排列就是如果元素相同，但是顺序不同，就是两个排列了。

used用于判断当前元素是否被使用过，1代表已经使用过了（当前深度下），就比如，你第一次取了2，下次深度就只能从1 3中取了

这题的思路重点就是运用好used这个boolean数组，而这题中取的元素就是树形结构中的叶子节点（即path的大小为size的时候）。每次取得一次元素，就把当前元素的下标对应used设置为true，回溯完成后，在改回false。

代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0){
            return result;
        }
        used = new boolean[nums.length];
        permuteHelper(nums);
        return result;
    }

    private void permuteHelper(int[] nums){
        if (path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++){
            if (used[i]){
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            permuteHelper(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

47.全排列 II

题目

参考文章

思路：重点也是树层上的去重，避免重复使用，使得结果集中出现重复的元素组合

在使用used过程中，只有used[i-1]=false而且nums[i]=nums[i-1]才表示是在同一层中，这样做到了层去重逻辑

部分思路逻辑已经在代码中

代码：

class Solution {
     //存放结果
    List<List<Integer>> result = new ArrayList<>();
    //暂存结果
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        Arrays.sort(nums);
        backTrack(nums, used);
        return result;
    }

    private void backTrack(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而且nums[i]=nums[i-1]才表示是在同一层中
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //如果同⼀树⽀nums[i]没使⽤过开始处理
            //即去掉数组中已经用过的元素
            if (used[i] == false) {
                used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用
                path.add(nums[i]);
                backTrack(nums, used);
                path.remove(path.size() - 1);//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;//回溯
            }
        }
    }
}