labuladong 回溯算法秒杀所有排列-组合-子集问题

于 2023-03-24 19:51:29 发布
阅读量238 收藏
点赞数
文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fxxkke/article/details/129756676
版权

文章目录

  • 回溯算法解决子集之类的问题
回溯算法的框架主要有：
result = []
def backtrack(路径, 选择列表):
   if 满足结束条件:
       result.add(路径)
       return
   
   for 选择 in 选择列表:
       做选择
       backtrack(路径, 选择列表)
       撤销选择

78. 子集

78. 子集

class Solution {
    //回溯算法
        List<List<Integer>> res = new LinkedList<>();
        //记录回溯算法的递归路径
        LinkedList<Integer> track = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backtrack(nums,0);
        return res;
    }
    void backtrack(int[] nums,int start){
        //前序位置，每一个节点的值都是一个子集
        res.add(new LinkedList<>(track));
        //回溯算法框架
        for(int i = start; i < nums.length ; i++){
            //做选择
            track.addLast(nums[i]);
            //进入下一个
            backtrack(nums,i+1);
            //撤销选择
            track.removeLast();
        }
    }
}

77. 组合

77. 组合
大小为 k 的组合就是大小为 k 的子集。

class Solution {

    List<List<Integer>> res = new LinkedList<>();
    // 记录回溯算法的递归路径
    LinkedList<Integer> track = new LinkedList<>();

    // 主函数
    public List<List<Integer>> combine(int n, int k) {
        backtrack(1, n, k);
        return res;
    }

    void backtrack(int start, int n, int k) {
        // base case
        if (k == track.size()) {
            // 遍历到了第 k 层，收集当前节点的值
            res.add(new LinkedList<>(track));
            return;
        }
        
        // 回溯算法标准框架
        for (int i = start; i <= n; i++) {
            // 选择
            track.addLast(i);
            // 通过 start 参数控制树枝的遍历，避免产生重复的子集
            backtrack(i + 1, n, k);
            // 撤销选择
            track.removeLast();
        }
    }
}

46. 全排列

46. 全排列

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        //记录路径
        LinkedList<Integer> track = new LinkedList<>();
        //路径中的元素会被标记为true，避免重复使用
        boolean[] used = new boolean[nums.length];
        backtrack(nums,track,used);
        return res;
    }

    void backtrack(int[] nums,LinkedList 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]){
                //如果已经在路径中，则跳过
                continue;
            }
            //做选择
            track.add(nums[i]);
            used[i] = true;
            //进入下一层决策树
            backtrack(nums,track,used);
            //取消选择
            track.removeLast();
            used[i] = false;
        }
    }
}

90. 子集 II

90. 子集 II
本题和子集 I的区别在于该数组存在重复元素

  • 标准的子集/组合问题是如何保证不重复使用元素的？
  • 答案在于 backtrack 递归时输入的参数 start：
class Solution {
    //回溯算法+减枝
    List<List<Integer>> res = new LinkedList<>();
    LinkedList track = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backtrack(nums,0);
        return res;

    }
    void backtrack(int[] nums,int start){
        res.add(new LinkedList<>(track));
        for(int i = start; i < nums.length; i ++){
            if( i > start && nums[i] == nums[i - 1]){
                continue;
                //值相同的相邻树枝，只遍历第一条
            }
            track.addLast(nums[i]);
            backtrack(nums,i+1);
            track.removeLast();
        }
    }
}

40. 组合总和 II

40. 组合总和 II

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        if(candidates.length == 0){
            return res;
        }
        //排序
        Arrays.sort(candidates);
        backtrack(candidates,0,target);
        return res;
    }
    void backtrack(int[] candidates,int start , int target){
        //结束条件
        if(sum == target){
            res.add(new LinkedList<>(track));
            return;
        }
        if(sum > target){
            return;
        }
        for(int i = start; i < candidates.length; i++){
            //剪枝 值相同的树枝，只遍历第一条
            if(i > start && candidates[i] == candidates[i - 1]){
                continue;
            }
            track.addLast(candidates[i]);
            sum += candidates[i];
            backtrack(candidates,i + 1,target);
            track.removeLast();
            sum -= candidates[i];
        }
    }
}

47. 全排列 II

47. 全排列 II
标准全排列算法之所以出现重复，是因为把相同元素形成的排列序列视为不同的序列，但实际上它们应该是相同的；而如果固定相同元素形成的序列顺序，当然就避免了重复。

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        //相同元素的全排列的去重，考虑使相同元素的位置固定
    Arrays.sort(nums);
    used = new boolean[nums.length];
    backtrack(nums);
    return res;
    }
    void backtrack(int[] nums){
        if(nums.length == track.size()){
            res.add(new LinkedList<>(track));
            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;
            }
            track.addLast(nums[i]);
            used[i] = true;
            backtrack(nums);
            track.removeLast();
            used[i] = false;
        }
    }
}

39. 组合总和

39. 组合总和

class Solution {

    List<List<Integer>> res = new LinkedList<>();
    // 记录回溯的路径
    LinkedList<Integer> track = new LinkedList<>();
    // 记录 track 中的路径和
    int trackSum = 0;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if (candidates.length == 0) {
            return res;
        }
        backtrack(candidates, 0, target);
        return res;
    }

    // 回溯算法主函数
    void backtrack(int[] nums, int start, int target) {
        // base case，找到目标和，记录结果
        if (trackSum == target) {
            res.add(new LinkedList<>(track));
            return;
        }
        // base case，超过目标和，停止向下遍历
        if (trackSum > target) {
            return;
        }

        // 回溯算法标准框架
        for (int i = start; i < nums.length; i++) {
            // 选择 nums[i]
            trackSum += nums[i];
            track.add(nums[i]);
            // 递归遍历下一层回溯树
            // 同一元素可重复使用，注意参数
            backtrack(nums, i, target);
            // 撤销选择 nums[i]
            trackSum -= nums[i];
            track.removeLast();
        }
    }
}

排列（元素无重可复选）

class Solution {

    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();

    public List<List<Integer>> permuteRepeat(int[] nums) {
        backtrack(nums);
        return res;
    }

    // 回溯算法核心函数
    void backtrack(int[] nums) {
        // base case，到达叶子节点
        if (track.size() == nums.length) {
            // 收集叶子节点上的值
            res.add(new LinkedList(track));
            return;
        }

        // 回溯算法标准框架
        for (int i = 0; i < nums.length; i++) {
            // 做选择
            track.add(nums[i]);
            // 进入下一层回溯树
            backtrack(nums);
            // 取消选择
            track.removeLast();
        }
    }
}

排列/组合/子集问题总结

  1. 元素无重不可复选，即 nums 中的元素都是唯一的，每个元素最多只能被使用一次，backtrack 核心代码如下:
/* 组合/子集问题回溯算法框架 */
void backtrack(int[] nums, int start) {
    // 回溯算法标准框架
    for (int i = start; i < nums.length; i++) {
        // 做选择
        track.addLast(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.removeLast();
    }
}

/* 排列问题回溯算法框架 */
void backtrack(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        // 剪枝逻辑
        if (used[i]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.addLast(nums[i]);

        backtrack(nums);
        // 撤销选择
        track.removeLast();
        used[i] = false;
    }
}
  1. 元素可重不可复选，即 nums 中的元素可以存在重复，每个元素最多只能被使用一次，其关键在于排序和剪枝，backtrack 核心代码如下：
Arrays.sort(nums);
/* 组合/子集问题回溯算法框架 */
void backtrack(int[] nums, int start) {
    // 回溯算法标准框架
    for (int i = start; i < nums.length; i++) {
        // 剪枝逻辑，跳过值相同的相邻树枝
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }
        // 做选择
        track.addLast(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.removeLast();
    }
}


Arrays.sort(nums);
/* 排列问题回溯算法框架 */
void backtrack(int[] nums) {
    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;
        track.addLast(nums[i]);

        backtrack(nums);
        // 撤销选择
        track.removeLast();
        used[i] = false;
    }
}
  1. 元素无重可复选，即 nums 中的元素都是唯一的，每个元素可以被使用若干次，只要删掉去重逻辑即可，backtrack 核心代码如下：
/* 组合/子集问题回溯算法框架 */
void backtrack(int[] nums, int start) {
    // 回溯算法标准框架
    for (int i = start; i < nums.length; i++) {
        // 做选择
        track.addLast(nums[i]);
        // 注意参数
        backtrack(nums, i);
        // 撤销选择
        track.removeLast();
    }
}


/* 排列问题回溯算法框架 */
void backtrack(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        // 做选择
        track.addLast(nums[i]);
        backtrack(nums);
        // 撤销选择
        track.removeLast();
    }
}
Fxxkke
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值