代码随想录第29天 回溯算法part05 * 491.递增子序列* 46.全排列* 47.全排列 II

491.递增子序列 

本题和大家刚做过的 90.子集II 非常像，但又很不一样，很容易掉坑里。 

代码随想录

视频讲解：回溯算法精讲，树层去重与树枝去重 | LeetCode：491.递增子序列_哔哩哔哩_bilibili

import java.util.ArrayList;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    //不能对数组元素进行排序
    //全局变量接收结果
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

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

    private void backTracking(int[] nums, int startIndex) {
        //分割问题终止条件，可不加 startIndex超出范围 for循环就不执行
        if (startIndex > nums.length) {
            return;
        }
        if (path.size() >= 2) {//要求序列至少为2
            result.add(new ArrayList<>(path));
            // 注意这里不要加return，因为要取树上的所有节点
        }
        //使用数组记录使用过的数值
        int[] used = new int[201];//每次递归都新建一个数组记录数据使用情况，因此不需要回溯
        //单层递归
        for (int i = startIndex; i < nums.length; i++) {
            //剪枝操作
            if ((!path.isEmpty() && nums[i] < path.get(path.size() - 1))// path为空 不满足递增
                    ||(used[nums[i] + 100] == 1))
                // used数组的大小为201，是为了确保能够存储数组nums中元素的范围。
                // 由于数组下标不能为负数，为了将元素映射到数组中，对元素进行偏移，将元素值加上100，
                // 使得元素值的范围在0到200之间，即nums[i] + 100作为used数组的下标。这样可以有效地标记元素的使用情况。
            {
                continue;//跳出本次循环
            }
            used[nums[i] + 100] = 1; //元素标记为1 ：使用过
            path.add(nums[i]);
            backTracking(nums, i + 1);//下一层递归
            path.removeLast(); //回溯
        }

    }
}
//leetcode submit region end(Prohibit modification and deletion)

46.全排列 

本题重点感受一下，排列问题 与 组合问题，组合总和，子集问题的区别。 为什么排列问题不用 startIndex 

代码随想录

视频讲解：组合与排列的区别，回溯算法求解的时候，有何不同？| LeetCode：46.全排列_哔哩哔哩_bilibili

import com.sun.org.apache.bcel.internal.generic.IfInstruction;

import java.awt.font.NumericShaper;
import java.util.ArrayList;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    //排列是有序的，与子集和组合不同
    //全局变量接收结果
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0) {
            return result;
        }
        //全局变量声明过，不需要实例化时写类型
        used = new boolean[nums.length];//不作为参数传入就不用预设默认值
        backTracking(nums);
        return result;
    }

    private 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; // path里已经收录的元素，直接跳过
            }
            used[i] = true;
            path.add(nums[i]);
            backTracking(nums);
            path.removeLast();
            used[i] = false;
        }

    }
}
//leetcode submit region end(Prohibit modification and deletion)

47.全排列 II 

本题 就是我们讲过的 40.组合总和II 去重逻辑 和 46.全排列 的结合，可以先自己做一下，然后重点看一下 文章中 我讲的拓展内容。 used[i - 1] == true 也行，used[i - 1] == false 也行 

代码随想录

视频讲解：回溯算法求解全排列，如何去重？| LeetCode：47.全排列 II_哔哩哔哩_bilibili

import java.util.ArrayList;
import java.util.Arrays;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    //包含重复数字，需要进行排序，进行去重
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.fill(used, false);
        Arrays.sort(nums);
        backTracking(nums, used);
        return result;
    }

    private void backTracking(int[] nums, boolean[] used) { //终止条件 子节点
        //终止条件
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            //剪枝
            // used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过
            // used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            //如果要对树层中前一位去重，就用used[i - 1] == false，如果要对树枝前一位去重用used[i - 1] == true。
            //一定要加上 used[i - 1] == false或者used[i - 1] == true，因为 used[i - 1] 要一直是 true 或者一直是false 才可以
            // 而不是 一会是true 一会又是false。 所以这个条件要写上。
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {//如果同⼀树⽀nums[i]没使⽤过开始处理
                used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用
                path.add(nums[i]);
                backTracking(nums, used);
                path.removeLast();//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;
            }
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)