代码随想录刷LeetCode | day29刷题回顾-CSDN博客

本文链接：https://blog.csdn.net/weixin_40142386/article/details/128321632

关键：if(i > 0 && used[i-1] == false && nums[i] == nums[i-1])

前沿：撰写博客的目的是为了再刷时回顾和进一步完善，其次才是以教为学，所以如果有些博客写的较简陋，是为了保持进度不得已而为之，还请大家多多见谅。

预：看到题目后的思路和实现的代码。

见：参考答案展示。

感思：对比答案后的思考，与之前做过的题目是否有关联。

行：

（1）对于没做出来的题目，阅读答案后重新做一遍；

（2）下次做题可以尝试改善的方向；

（3）有助于理解的相关的题目

优先级：做题进度＞学习&总结＞默写回顾＞做题数量

题目回顾

1.全排列

题目链接：46.全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路：全排列→顺序不同排序不同→不用start，used保持同树枝上不重复

与组合问题的区别：

组合问题是无序的，不同顺序都属于同个组合，所以使用start保证每次遍历不会重复。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        backtracking(nums);
        return result;
    }
    void backtracking(int[] nums){
        if(path.size() == nums.length){
            result.add(new ArrayList(path));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(used[i]){
                // System.out.println("used["+i+"]:true,nums:"+nums[i]);
                continue;
            }
            // if(path.size() > 0 && nums[i] == path.get(path.size()-1)){
            //     continue;
            // }
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

2.全排列 II

题目链接：47.全排列 II

关键：if(i > 0 && used[i-1] == false && nums[i] == nums[i-1])

i > 0保证不越界
nums[i] == nums[i-1]可能树同层重复的必要条件：序列前后值相等
1. 但其实遍历时，树枝重复也是满足条件的，所以仍需要区分条件。
当used[i-1]==false，选择false，相当于剪枝，效率更高。
1. 无论used[i-1]为true或false，都表示树层重复。
2. false则是遍历第一个，排除后面树层重复。
3. true则是排除前面树层重复的元素，一直遍历到最后一个才存储。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    boolean[] used; 
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backtracking(nums);
        return result;
    }
    void backtracking(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;
            }
            if(i > 0 && used[i-1] && nums[i] == nums[i-1]){
                // System.out.println(used[i-1]);
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

3.递增子序列

题目链接：491.递增子序列

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

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

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/increasing-subsequences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码仍存在问题

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        // 两个整数相等，也可以视作递增序列的一种特殊情况
        if(nums.length == 1){
            return result;
        }
        // Arrays.sort(nums);
        backtracking(nums,0);
        return result;
    }
    void backtracking(int[] nums,int start){
        if(path.size() >= 2){
            result.add(new ArrayList(path));
        }
        for(int i = start;i < nums.length;i++){
            // if(i > start && nums[i] <= nums[i-1]){
            //     continue;
            // }
            if(path.size() > 0 && nums[i] < path.get(path.size()-1)){
                continue;
            }
            // 没有排序，不能同层判断重复。
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.removeLast();
        }
    }
}