力扣算法 Java 刷题笔记【回溯算法篇 DFS】hot100（一）全排列、子集、组合 4

心海非海_

已于 2022-07-26 13:00:43 修改

阅读量405

点赞数 3

分类专栏：数据结构与算法文章标签： leetcode 算法 java 回溯

于 2022-01-23 12:58:24 首次发布

本文链接：https://blog.csdn.net/weixin_46644403/article/details/122577641

版权

数据结构与算法专栏收录该内容

51 篇文章 7 订阅

订阅专栏

文章目录

1. 全排列（中等）
2. 全排列 II（中等）
3. 子集（中等）
4. 组合（中等）

1. 全排列（中等）

地址: https://leetcode-cn.com/problems/permutations/
2022/01/23
做题反思：

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(nums, track);
        return res;
    }
    void backtrack(int[] nums, LinkedList<Integer> track) {
        if (track.size() == nums.length) {
            res.add(new LinkedList(track));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (track.contains(nums[i])) {
                continue;
            }
            track.add(nums[i]);
            backtrack(nums, track);
            track.removeLast();
        }
    }
}

在这里插入图片描述

2. 全排列 II（中等）

地址: https://leetcode.cn/problems/permutations-ii/
2022/07/26
做题反思：

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        LinkedList<Integer> track = new LinkedList<>();
        boolean[] used = new boolean[nums.length];

        traverse(nums, track, used);
        return res;
    }

    void traverse(int[] nums, LinkedList<Integer> track, boolean[] used) {
        if (track.size() == nums.length) {
            res.add(new LinkedList(track));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i] == true) {
                continue;
            }

            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue;
            }

            track.add(nums[i]);
            used[i] = true;
            traverse(nums, track, used);
            track.pollLast();
            used[i] = false;
        }
    }
}

3. 子集（中等）

地址: https://leetcode-cn.com/problems/subsets/
2022/01/23
做题反思：

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(nums, track, 0);
        return res;
    }
    void backtrack(int[] nums, LinkedList<Integer> track, int start) {
        res.add(new LinkedList(track));
        for (int i = start; i < nums.length; i++) {       
            track.add(nums[i]);
            backtrack(nums, track, i + 1);
            track.removeLast();
        }
    }
}

在这里插入图片描述

4. 组合（中等）

地址: https://leetcode-cn.com/problems/combinations/
2022/01/23
做题反思：

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(n, k, track, 1);
        return res;
    }
    void backtrack(int n, int k, LinkedList<Integer> track, int start) {
        if (track.size() == k) {
            res.add(new LinkedList(track));
            return;
        }
        for (int i = start; i <= n; i++) {
            if (track.contains(i)) {
                continue;
            }
            track.add(i);
            backtrack(n, k, track, i + 1);
            track.removeLast();
        }
    }
}