代码随想录算法训练营第二十九天 | 回溯算法part05

题目：

491.递增子序列
46.全排列
47.全排列 II

---

学习内容：

491.递增子序列

首先，本题也需要去重，但是由于是求自增子序列，那么就不能像之前的题目一样先排序了，否则没有意义。下图为此树形结构：

我们还是应用回溯三部曲：

1. 确定递归函数参数；
2. 确定终止条件；
3. 确定单层搜索逻辑；

这里一定要注意排除的逻辑：分为两种，一个是排除不符合题目要求非递减的path，一个是去重。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return result;
    }
    public void backtracking(int[] nums, int startIndex) {
        if (path.size() >= 2) {
            result.add(new ArrayList<>(path));
        }
        HashSet<Integer> hashset = new HashSet<>();
        for (int i = startIndex; i < nums.length; i++) {
            // 排除非递减和去重，如果path不为空且path最后一个元素大于num[i](说明不是非递减序列)，或者有元素重复
            if(!path.isEmpty() && path.get(path.size() - 1) > nums[i] || hashset.contains(nums[i])) {
                continue;
            } 
            hashset.add(nums[i]);
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.removeLast();

        }
    }
}

46.全排列

排列和组合问题有相同也有不同，相同之处：

• 排列和组合基本都能套用同一个模板，即回溯三部曲；

不同之处：

• 组合问题有去重环节，因为[1, 2]和[2, 1]在组合问题是一样的，但是在排列问题却不同。具体在代码中，就是在组合问题中需要startIndex去重，但是在排列问题中无需startIndex。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return result;
    }
    public void backtracking(int[] nums) {
        if (path.size() == nums.length) {
            result.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.removeLast();
        }
    }
}

47.全排列 II

这道题和上一题的区别就是，nums可能有重复的。所以要进行去重，应该先排序再去重。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(nums, used);
        return result;
    }
    public 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++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == true) {
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums, used);
            path.removeLast();
            used[i] = false;
        }
    }
}

学习时间：

2024.4.8