代码随想录算法训练营第二十九天|回溯算法part05|* 491.递增子序列* 46.全排列* 47.全排列 II

最新推荐文章于 2024-08-29 16:37:54 发布

2301_78266314

最新推荐文章于 2024-08-29 16:37:54 发布

阅读量111

点赞数

分类专栏：代码随想录算法训练营文章标签：算法

本文链接：https://blog.csdn.net/2301_78266314/article/details/131569574

版权

代码随想录算法训练营专栏收录该内容

51 篇文章 1 订阅

订阅专栏

文章介绍了使用回溯法解决LeetCode中的递增子序列（Non-decreasingSubsequences）和全排列（PermutationsI&II）问题。通过一维和二维数组管理路径和结果，避免重复并找到所有可能的解。

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

491.递增子序列 Non-decreasing Subsequences - LeetCode

二维 res

一维 path

void backtracking(nums, startIndex)

if (path.size() > 1) res.add(path);

Set<Integer> used ;//记录

for (int i = startIndex; i < nums.length; i++)

if（!path.size().isEmpaty()&& nums[i] < path.back && set.contains[i]) continue;

used.add(nums[i]);

path.add(nums[i]);

backtracking(nums, i + 1);

path.remove(path.size() - 1);

class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        backtracking(res, path, nums, 0);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] nums, int startIndex) {
        if (path.size() > 1) {
            res.add(new ArrayList<>(path));
        }
        Set<Integer> set = new HashSet<>();
        for (int i = startIndex; i < nums.length; i++) {
            if (!path.isEmpty() && path.get(path.size() - 1) > nums[i] || set.contains(nums[i])) continue;
            set.add(nums[i]);
            path.add(nums[i]);
            backtracking(res, path, nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

* 46.全排列 Permutations - LeetCode

二维 res

一维 path

void backtracking(nums, used,)

if (path.size == nums.length)

res.add(path);

return;

for (int i = 0; i < nums.size(); i++)

if (used[i] == true) continue;

path.add(nums[i]);

backtracking(nums, used)

used[i] = false;

path.remove(path.size() - 1);

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        backtracking(res, path, nums, used);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, 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]) continue;
            path.add(nums[i]);
            used[i] = true;
            backtracking(res, path, nums, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }


}

* 47.全排列 II Permutations II - LeetCode

二维 res

一维 path

Arrays.sort(nums);

void backtracking(nums, used)

if (path.size() == nums.length)

res.add(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;

path.add（nums[i]);

used[i] = true;

backtracking(nums, used);

path.remove(path.size() - 1);

used[i] = false;

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(res, path, nums, used);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, 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]) continue;
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
                used[i] = true;
                path.add(nums[i]);
                backtracking(res, path, nums, used);
                path.remove(path.size() - 1);
                used[i] = false;            
        }
    }
}