代码随想录第29天: 回溯part05

最新推荐文章于 2024-11-12 12:29:51 发布

sevune

最新推荐文章于 2024-11-12 12:29:51 发布

阅读量135

点赞数 3

分类专栏：代码随想录文章标签：算法数据结构回溯 leetcode

本文链接：https://blog.csdn.net/sevune/article/details/137936187

版权

代码随想录专栏收录该内容

37 篇文章 1 订阅

订阅专栏

本文介绍了在力扣平台上两道编程题目——递增子序列和全排列的解决方案，主要运用了回溯法（backTracking）来遍历所有可能的子序列或排列，确保结果的完整性和唯一性。

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

力扣 491.递增子序列

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

    public void backTracking(int[] nums, int startId) {
        if(path.size() >= 2) {
            result.add(new ArrayList<>(path));
        }
        boolean[] used = new boolean[205];
        for(int i = startId; i < nums.length; i++) {
            if(!path.isEmpty() && nums[i] < path.get(path.size() - 1)) {
                continue;
            }
            if(used[nums[i] + 100]) {
                continue;
            }
            path.add(nums[i]);
            used[nums[i] + 100] = true;
            backTracking(nums, i + 1);
            path.removeLast();
        }
    }

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

力扣 46.全排列

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

    public void backTracking(int[] nums, boolean[] used) {
        if(path.size() == nums.length) {
            result.add(new ArrayList<>(path));
        }
        for(int i = 0; i < nums.length; i++) {
            if(used[nums[i] + 10]) {
                continue;
            }
            path.add(nums[i]);
            used[nums[i] + 10] = true;
            backTracking(nums, used);
            path.removeLast();
            used[nums[i] + 10] = false;
        }
    }

    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[25];
        backTracking(nums, used);
        return result;
    }
}

力扣 47.全排列 II

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

    public void backTracking(int[] nums, boolean[] usedId) {
        if(path.size() == nums.length) {
            result.add(new ArrayList<>(path));
        }
        for(int i = 0; i < nums.length; i++) {
            // 该句是为了排除同一树枝使用相同元素的情况
            if(usedId[i] == true) {
                continue;
            }
            // 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] && !usedId[i - 1]) {
                continue;
            }
            path.add(nums[i]);
            usedId[i] = true;
            backTracking(nums, usedId);
            path.removeLast();
            usedId[i] = false;
        }
    }

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