代码随想录-刷题第二十九天

491. 递增子序列

题目连接：491. 递增子序列

思路：将问题抽象为树形结构，使用回溯法。本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。所以不能使用之前的去重逻辑！

HashSet是记录本层元素是否重复使用，新的一层set都会重新定义（清空），所以要知道set只负责本层！

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

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

    // 回溯算法主函数
    private void backtracking(int[] nums, int start) {
        if (path.size() >= 2) {
            // 找到一个合法答案
            res.add(new ArrayList<>(path));
        }
        // 使用set来对本层元素进行去重
        HashSet<Integer> used = new HashSet<>();
        // 回溯算法标准框架
        for (int i = start; i < nums.length; i++) {
            // 保证集合中元素都是递增顺序
            if (!path.isEmpty() && path.get(path.size() - 1) > nums[i]) {
                continue;
            }
            // 保证不要重复使用相同的元素
            if (used.contains(nums[i])) {
                continue;
            }
            // 选择 nums[i]
            // 记录这个元素在本层用过了，本层后面不能再用了
            used.add(nums[i]);
            path.add(nums[i]);
            // 递归遍历下一层回溯树
            backtracking(nums, i + 1);
            // 撤销选择 nums[i]
            path.remove(path.size() - 1);
        }
    }
}

---

46. 全排列

题目链接：46. 全排列

思路：将问题抽象成树形结构，使用回溯法搜索结果。

此时可以感受出排列问题的不同：

• 每层都是从0开始搜索而不是start
• 需要used数组记录path里都放了哪些元素了

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

    /* 主函数，输入一组不重复的数字，返回它们的全排列 */
    public List<List<Integer>> permute(int[] nums) {
        // 「路径」中的元素会被标记为 true，避免重复使用
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        backtracking(nums, used);
        return res;
    }

    // 路径：记录在 path 中
    // 选择列表：nums 中不存在于 path 的那些元素（used[i] 为 false）
    // 结束条件：nums 中的元素全都在 path 中出现
    private 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 (used[i]) {
                // nums[i] 已经在 path 中，跳过
                continue;
            }
            // 做选择
            path.add(nums[i]);
            used[i] = true;
            // 进入下一层决策树
            backtracking(nums, used);
            // 取消选择
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }
}

另一种解法：

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

    // 通过判断path中是否存在数字，排除已经选择的数字
    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return res;
    }

    private void backtracking(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            // 如果path中已有，则跳过
            if (path.contains(nums[i])) continue;
            path.add(nums[i]);
            backtracking(nums);
            path.remove(path.size() - 1);
        }
    }
}

---

47. 全排列II

题目链接：47. 全排列 II

思路：将问题抽象成树形结构，同一树层需要去重，同一树枝上也要判断是否使用过（注意这里是如何判断的）

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

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

    public List<List<Integer>> permuteUnique(int[] nums) {
        // 先排序，让相同的元素靠在一起
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        backtracking(nums, used);
        return res;
    }

    private 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++) {
            // used[i - 1] == true，说明同⼀树枝nums[i - 1]使⽤过
            // used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            // 如果同⼀树枝nums[i]没使⽤过开始处理
            if (used[i] == false) {
                // 标记同⼀树枝nums[i]使⽤过，防止同一树枝重复使用
                path.add(nums[i]);
                used[i] = true;
                backtracking(nums, used);
                // 回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;// 回溯
                path.remove(path.size() - 1);
            }
        }
    }
}

---