算法DAY29 | 【LeetCode力扣】491.递增子序列 / 46.全排列 / 47.全排列II

最新推荐文章于 2024-08-30 10:38:03 发布

Kingston8GB

最新推荐文章于 2024-08-30 10:38:03 发布

阅读量92

点赞数

分类专栏：算法文章标签： leetcode 算法 java 数据结构剪枝

本文链接：https://blog.csdn.net/Kingston8GB/article/details/131271827

版权

算法专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章介绍了如何使用递归和回溯算法解决全排列（包括无重复全排列）和递增子序列的问题。在491题中，重点在于路径长度大于等于2且元素递增的条件；46题全排列是简单的所有可能排列；47题全排列II则需要去除重复的排列，通过树枝和树层去重策略实现。

摘要由CSDN通过智能技术生成

文章目录

491.递增子序列

标签：递归、回溯
难度：8.0

和子集II的区别有：

虽然遍历每个节点还是要把path加入到res里，但是这次要判断path的长度，大于等于2才能加
数组不是递增有序，所以对于continue条件的判断，增加了是否小于前一个元素
used数组记录同层兄弟是否访问过，每一层都会有一个新的，所以不需要回溯

List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();

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

    return res;
}

public void backTracking(int[] nums, int startIndex){
    if(path.size() >= 2){
        res.add(new ArrayList<>(path));
    }

    boolean[] used = new boolean[201];

    for(int i = startIndex; i < nums.length; i++){
        if(path.size() > 0 && nums[i] < path.get(path.size() - 1) || used[nums[i] + 100]){
            continue;
        }

        path.add(nums[i]);
        used[nums[i] + 100] = true;
        backTracking(nums, i+1);
        path.remove(path.size() - 1);
        //没有对used的回溯，因为每一层要创建一个新的空used
    }
}

46.全排列

标签：递归、回溯
难度：7.5

排列问题的不同：

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

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];
    permuteHelper(nums);
    return result;
}

private void permuteHelper(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;
        }
        used[i] = true;
        path.add(nums[i]);
        permuteHelper(nums);
        path.removeLast();
        used[i] = false;
    }
}

47.全排列II

标签：递归、回溯
难度：8.0

要去重，但是此题树枝去重和树层去重都是可以的。

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.fill(used, false);
    Arrays.sort(nums);
    backTrack(nums, used);
    return result;
}

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