代码随想录Day29打卡

①、递增子序列

给你一个整数数组 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]]

思路：

        采用回溯算法，再往临时List<Integer> tmp中添加数之前，判断当前数是否大于tmp中最大的数(即最后一个数)，若符合，则加入。去重操作，由于排序会使得递增子序列发生改变(增多)，故之前的标记法无法使用，可以使用hashmap映射。在每层单层逻辑中，判断当前hashmap中是否包含该数，若包含，则跳过。因为hashmap代表N叉树从头结点的层次遍历，hashmap出现的数则代表之前已经遍历过，再次遍历则重复。

代码：

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

    private List<List<Integer>> res = new ArrayList<>();
    private LinkedList<Integer> tmp = new LinkedList<>();

    public void backtracking(int[] nums,int startIndex){
        if(tmp.size() >= 2){
            res.add(new ArrayList<>(tmp));
        }

        Set<Integer> set = new HashSet<>();
        //单层逻辑
        for(int i = startIndex;i < nums.length;i++){
            if(!tmp.isEmpty() && tmp.get(tmp.size() - 1) > nums[i] || set.contains(nums[i])){
                continue;
            }
            set.add(nums[i]);
            tmp.add(nums[i]);
            //递归
            backtracking(nums,i + 1);
            //回溯
            tmp.removeLast();
        }
    }

②、全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

事例：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路：

        跟之前的组合类似，采用回溯算法。组合问题中，使用index标记当前遍历的位置，每次只能后从面遍历，保证了组合顺序就是原先数组顺序往后遍历，不会打乱。全排列中，需要打乱顺序，故可以使用标记法，让nums从0遍历，若标记数组中没有，则添加到临时list当中，然后继续递归。当list中长度等于nums长度时，则标志新的排列出现。

递归三部曲：

        结束条件：临时list长度大于等于nums长度

        返回值及参数：无返回值，参数：int[] nums,int[] used         used标记当前下标是否使用过

        单层逻辑：遍历nums，配合used，添加未使用过的值然后继续遍历。

代码：

public List<List<Integer>> permute(int[] nums) {
        int[] used = new int[nums.length];
        backtracking(nums,used);
        return res;
    }

    private List<List<Integer>> res = new ArrayList<>();
    private LinkedList<Integer> tmp = new LinkedList<>();

    public void backtracking(int[] nums,int[] used){
        if(tmp.size() == nums.length){
            res.add(new ArrayList<>(tmp));
        }

        for(int i = 0;i < nums.length;i++){
            if(used[i] == 1) continue;
            tmp.add(nums[i]);
            used[i] = 1;
            //递归
            backtracking(nums,used);
            //回溯
            tmp.removeLast();
            used[i] = 0;
        }
    }

③、全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

事例：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

思路：

        就是上面的全排列加上去重操作，由于排列是打乱顺序的，故可以先排好序然后使用标记法进行去重，也可以在单层逻辑中采用hashmap进行去重。

代码：

public List<List<Integer>> permuteUnique(int[] nums) {
        int[] used = new int[nums.length];
        //int[] isRepeat = new int[nums.length];
        //Arrays.sort(nums);
        backtracking(nums,used);
        return res;
    }

    private List<List<Integer>> res = new ArrayList<>();
    private LinkedList<Integer> tmp = new LinkedList<>();

    public void backtracking(int[] nums,int[] used){
        if(tmp.size() == nums.length){
            res.add(new ArrayList<>(tmp));
        }

        Set<Integer> set = new HashSet<>();
        for(int i = 0;i < nums.length;i++){
            if(used[i] == 1 || set.contains(nums[i])){
                continue;
            }
            tmp.add(nums[i]);
            used[i] = 1;
            set.add(nums[i]);
            //递归
            backtracking(nums,used);
            //回溯
            tmp.removeLast();
            used[i] = 0;
        }
    }

参考：代码随想录 (programmercarl.com)