day29 【回溯算法】491.递增子序列 | 46.全排列 | 47.全排列Ⅱ

491.递增子序列

• 491.递增子序列

• 代码随想录 | 讲解链接

• 题意：给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

    示例:
    
    输入: [4, 6, 7, 7]
    输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]
    
    说明:
    给定数组的长度不会超过15。
    数组中的整数范围是 [-100,100]。
    给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。
  

• 思路：
  

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new LinkedList<>();

    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return res;
        //这里不能写return；
    }

    public void backtracking(int[] nums, int startIndex) {
        //最下长度是2，只要符合条件的path长度大于2了，就把这条ptah加入res
        if(path.size() >= 2) {
            res.add(new ArrayList<>(path));
        }

        ///因为nums[i]是-100到100.共201个数。
        int[] used = new int[201];
        for(int i = startIndex; i < nums.length; i++) {
            //如果新nums比最后一个数小即不是递增 或 新num曾经在同一层使用过，跳出此次循环
            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]);
            backtracking(nums, i+1);
            //没有used[nums[i] + = 100] = 0 是因为每次调用backtracking时都重新new了一个used数组，是新的，每次都更新了。
            path.remove(path.size() -1);
        }
    }
}

46.全排列

• 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]]
    
    示例 2：
    输入：nums = [0,1]
    输出：[[0,1],[1,0]]
    
    示例 3：
    输入：nums = [1]
    输出：[[1]]
  

• 思路：用used记录用过的元素，不用startIndex ，因为全排列所有的元素不论顺序如何都要被选中，但是已经选过的元素不再重复使用，所以要有used
  

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        backtracking(nums);
        return res;
    }

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

        for(int i = 0; i < nums.length; i++) {
            if(used[i]) {
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums);
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }
}

47.全排列Ⅱ

• 47.全排列Ⅱ | 题目链接

• 代码随想录 | 讲解链接

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

    示例 1：
    输入：nums = [1,1,2]
    输出：
    [[1,1,2],
     [1,2,1],
     [2,1,1]]
     
    示例 2：
    输入：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 LinkedList<>();
    int[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new int[nums.length];
        Arrays.sort(nums);
        backtracking(nums, used);
        return res;
    }

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

        for(int i = 0; i < nums.length; i++) {
            // used[i - 1] == 1，说明同⼀树⽀nums[i - 1]使⽤过
            // used[i - 1] == 0，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if(i > 0 && nums[i] == nums[i-1] && used[i-1] == 1 ) {
                continue;
            }

            if(used[i] == 0) {
                used[i] = 1;
                path.add(nums[i]);
                backtracking(nums, used);
                used[i] = 0;
                path.remove(path.size() - 1);
            }      
        }
    }
}