代码随想录：回溯14-17

491.非递减子序列

题目

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

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

示例 1：

输入：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]]

代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums,0);
        return res;
    }
    public void backTracking(int[] nums,int index){
        //类似子集要收集中间节点，但这里只要收集第二层开始的节点
        if(path.size() >= 2){
            res.add(new ArrayList<>(path));
            //这里不用return，47后面也要搜集67
        }
        //终止条件
        if(index == nums.length){
            return;
        }
        //set表示的是同一层的元素，4767有一个set，767一个set，在同一层去重
        HashSet<Integer> set = new HashSet<>();
        for(int i=index; i < nums.length; i++){
            //4767,path=47,476不递增不要continue，继续收集477
            if(path.size() > 0 && nums[i] < path.get(path.size()-1)){
                continue;
            }
            //4767中的第二个7要去重，树的同一层都要去重，由于nums不连续，用set去重
            if(set.contains(nums[i])){
                continue;
            }
            set.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

总结

        和子集类似，也要收集处理叶子节点之外的节点。和子集不同的是：

        ①子集要收集所有中间节点，而这里是收集递增子序列，所以path长度到2才能开始收集，且当序列不递增的情况也不能收集，比如4767，path长度为1的第一层树高节点不用收集，path=47，继续收集67时，476不递增也不能收集。

        ②子集的去重可以靠sort+前后元素比较进行去重，但由于这里找的是递增子序列，sort之后会破坏原来的序列，比如4767排序之后会收集出4677，这个应该是没有的。因此，这里的去重要用set，可以在每一个节点位置设置一个set，比如4767的set会过滤第二个7,767的set也会过滤第二个7。但注意，一定是树中的每一个节点都有一个set，因为我们去重，也是针对每一个节点。

46.全排列

题目

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

示例 1：

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

代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;  //used用来表示元素是否加入path
    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length]; //初始化全为false
        backTracking(nums,used);
        return res;
    }

    public void backTracking(int[] nums,boolean[] used){
        //终止条件：收集到叶子节点
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i = 0; i < nums.length; i++){
            //123,收集1后，used=[100],下一层123,1被continue
            //used用于控制元素是否被收集过，和path其实是对应的
            if(used[i] == true){
                continue;
            }
            path.add(nums[i]);
            //收集到path中，used改为true
            used[i] = true;
            backTracking(nums,used);
            //从path中移除，used改为false
            used[i] = false;
            path.remove(path.size()-1);
        }
    }
}

总结

        全排列收集的都是叶子节点，当path长度==nums长度，就add和return就行。

        全排列最核心的是如何控制和记录哪些元素已经加入path，不同于之前的排列组合，用index控制从那个元素开始继续选择，全排列是123,132,213,231,312,321，每一层的每个节点都应该有123，然后用used的布尔数组，来控制元素是否已经加入path，比如path=12，used=[1,1,0]。

        因此，path的add和used修改为true一一对应，path的remove和used修改为false一一对应。

        核心还是要理解用used的目的是记录path中已经加入过的元素，表示的是该节点处path的状态。

47.全排列II

题目

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

示例 1：

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

代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;  //used用来表示元素是否加入path
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new boolean[nums.length];
        Arrays.fill(used,false);
        backTracking(nums,used);
        return res;
    }
    public void backTracking(int[] nums,boolean[] used){
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i=0; i < nums.length; i++){
            //已经加入path的不用继续排列组合
            if(used[i] == true){
                continue;
            }
            //去重针对的是同一个节点中的数字，即同一层去重
            //1112，在第一层要去除第二、三个1
            //112，第一个1不能被去重（同一个树枝不用去重），i和i-1相同时还要求i-1是没有加入path的
            //used[i-1] == false条件要求：i和i-1相同 && i-1是没有加入path的
            if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false){
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backTracking(nums,used);
            used[i] = false;
            path.remove(path.size()-1);
        }
    }
}

总结

        和全排列类似，用used布尔数组表示path中已经有的数字，但在全排列的基础上要进行去重，因此要先对nums进行sort。如1112。

        去重的基本条件是i>0,nums[i] == nums[i-1]，如果当前元素和前一个元素一样，就需要去重。

        但注意1112，第一层取了1，第二层还有112，used=[1,0,0,0]，第二层112中的第一个1是树枝上的重复，不能被去重，第二个2是树层上的的重复才需要去重。

        因此，去重条件还需要保证，当i和i-1数字相同时，还要求i-1没有加入path，used[i] == false。比如112的第一个1和前面的1一样，但是由于前面的1是true是已经加入path的数字，属于统一树枝上的重复，不用去重。

        去重核心还是要理解，去重针对的是同层的，而同一个树枝上的数字可以重复，以1111特殊情况理解就行。