代码随想录算法训练营-day29-491. 递增子序列、46.全排列、47.全排列 II

491. 递增子序列

1. 学习文章链接：
2. 思路：在子集的基础上去增加判断条件，即判断是否递增。
3. 代码：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracing(nums, 0);
        return res;
    }
    public void backtracing(int[] nums, int startIndex) {
        if (path.size() > 1) {
            res.add(new ArrayList<>(path));
            //注意要遍历全数，所以不能有return
        }
        //used数组就是用来去重的
        int[] used = new int[201];
        //-100 <= nums[i] <= 100，所以只需要定义一个长度为201的数组
        for (int i = startIndex; i < nums.length; i++) {
            if (!path.isEmpty() && nums[i] < path.get(path.size() - 1) || used[nums[i] + 100] == 1) continue;
            used[nums[i] + 100] = 1;
            path.add(nums[i]);
            backtracing(nums, i + 1);
            path.removeLast();
        }
    }
}

46.全排列

1. 学习文章链接：
2. 思路：注意两点：
   1. return的使用，详情见注释。
   2. used数组的使用。
3. 代码：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backtracing(nums, used);
        return res;
    }
    public void backtracing(int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;                     //这题并没有遍历所有可能，子集、子序列才是遍历所有的可能，因此这里需要return；
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == true) continue;//去重逻辑。
            used[i] = true;
            path.add(nums[i]);
            backtracing(nums, used);
            used[i] = false;
            path.removeLast();
        }
    }
}

47.全排列 II

1. 学习文章链接：
2. 思路：基于全排列的基础上进行，不同的是，这里增加了重复元素，记得要排序哦。
3. 代码：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();    
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        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++){
            //对于全排列的问题，树层去重和树枝去重都是可以，结果一样。
            if(i > 0 && nums[i] == nums[i -1] && used[i - 1] == false) continue;
            //一定要满足当前未被使用过才可以。
            if(used[i] == false){
                used[i] = true;
                path.add(nums[i]);
                backtracking(nums, used);
                used[i] = false;
                path.removeLast();
            }
        }
    }
}