回溯法，子集选择合集

最新推荐文章于 2023-04-18 19:10:58 发布
最新推荐文章于 2023-04-18 19:10:58 发布
阅读量279 收藏
点赞数
分类专栏： 算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CsWarmSun/article/details/113734777
版权

框架

回溯的核心特征，做选择。

回溯主要基于递归，它的特点是选择以及撤销选择，非常经典。子问题性质不是很明显。算法复杂度可以从子集数考虑，空间复杂度则一般为递归深度N。

回溯法框架如下：

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
		剪枝
        做选择
        backtrack(路径, 选择列表)
        撤销选择

集合选择（子集数，全排列）是典型的回溯法应用，而且它们的算法非常规则，简洁。

以40，求子集组合为target的所有可能，元素不可重复，但可选集合有重复。

public class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        // 排序，方便去重
        Arrays.sort(candidates);
        backtrack(candidates, target, 0, new ArrayList<>(), res);
        return res;
    }

    private void backtrack(int[] nums, int sum, int k, ArrayList<Integer> cur, List<List<Integer>> res) {
        // 满足条件加入集合
        if(sum == 0) res.add(new ArrayList<>(cur));
        else if (sum < 0) return;
        else {
            // 选择所有状态
            for (int i = k; i < nums.length; i++) {
                // 可选集合去重
                if (i > k && nums[i] == nums[i-1])continue;
                // 回溯
                cur.add(nums[i]);
                backtrack(nums, sum - nums[i], i + 1, cur, res);
                cur.remove(cur.size() - 1);
            }
        }
    }
}

上述算法包含了集合选择题目的所有核心要点（注释）。

  • 为何是子集数？

    事实上这个算法不算直观，递归树也不算直观。但观察状态选择部分，可以发现，对于每个状态，它都有两个分支，选择（加入），或者不选，直接i++。因而本质就是子集数。

  • **全排列为何是子集数？**其实唯一的区别就是，全排列每次都考虑所有状态，而子集数选过的之前的状态不再考虑（关键是上述回溯调用的k值）。另外全排列需要标记。

  • 子集数去重，这是个很抽象的点，理解请参考 47 有重复的全排列。它的本质是，对可选集合去重，实际操作就是上述代码的sort和for中的if部分。

  • 考虑空集，请参考题目78，90.

问题

78. Subsets

子集数

https://leetcode.com/problems/subsets/

/*
* Runtime: 0 ms, faster than 100.00% of Java online submissions for Subsets.
* Memory Usage: 39.7 MB, less than 16.56% of Java online submissions for Subsets.
* */
public class SolutionV2 {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtrack(nums, 0, new ArrayList<>(), res);
        return res;
    }

    private void backtrack(int[] nums, int k, ArrayList<Integer> cur, List<List<Integer>> res) {
        // 包括空的简洁实现方法，相当于在nums后加上null元素
        res.add(new ArrayList<>(cur));

        for (int i = k; i < nums.length; i++) {
            cur.add(nums[i]);
            backtrack(nums, i + 1, cur, res);
            cur.remove(cur.size() - 1);
        }
    }
}

90. Subsets II

子集数，集合有重复元素，求出子集不得重复

https://leetcode.com/problems/subsets-ii/

/*
Runtime: 1 ms, faster than 99.52% of Java online submissions for Subsets II.
        Memory Usage: 39.5 MB, less than 33.78% of Java online submissions for Subsets II.
*/

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(nums, 0, new ArrayList<>(), res);
        return res;
    }

    private void backtrack(int[] nums, int k, ArrayList<Integer> cur, List<List<Integer>> res) {
        // 包括空的简洁实现方法，相当于在nums后加上null元素
        res.add(new ArrayList<>(cur));

        for (int i = k; i < nums.length; i++) {
            if (k < i && nums[i] == nums[i-1]) continue;
            cur.add(nums[i]);
            backtrack(nums, i + 1, cur, res);
            cur.remove(cur.size() - 1);
        }
    }
}

46. Permutations

全排列
https://leetcode.com/problems/permutations/

/*

Runtime: 2 ms, faster than 49.39% of Java online submissions for Permutations.
        Memory Usage: 39.1 MB, less than 82.56% of Java online submissions for Permutations.
*/

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Map<Integer, Boolean> flag = new HashMap<>();

        backtrack(nums,  new ArrayList<>(), res, flag);
        return res;
    }
    private void backtrack(int[] nums,ArrayList<Integer> cur, List<List<Integer>> res, Map<Integer, Boolean> flag) {
        if (cur.size() == nums.length) {
            res.add(new ArrayList<>(cur));
        } else {
            for (int i = 0; i < nums.length; i++) {
                if (flag.getOrDefault(i, false)) continue;
                cur.add(nums[i]);
                flag.put(i, true);
                backtrack(nums, cur, res, flag);
                cur.remove(cur.size() - 1);
                flag.put(i, false);
            }
        }
    }
}

47 Permutations II

全排列，元素有重复

https://leetcode.com/problems/permutations-ii/

/*
 * 47. Permutations II
 * 全排列
 * https://leetcode.com/problems/permutations-ii/
 * */

/*
(i > 0 && nums[i] == nums[i - 1] && !flag[i-1])该条件是去重的关键
按照类似的调节，排序后的数组重复元素优先只会选择第一个，以[1 1 2]为例子，该递归树被去重为如下，这也是在子集数去重中的原理——每次可选集合没有重复元素
         / | \
        1  1  2
       /|\
      1 1 2
     /|\
    1 1 2
>>>>>>
         / \
        1   2
       / \
      1   2
     / \
    1   2
Runtime: 1 ms, faster than 98.93% of Java online submissions for Permutations II.
Memory Usage: 39.8 MB, less than 38.95% of Java online submissions for Permutations II.
 */

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

    private void backtrack(int[] nums, ArrayList<Integer> cur, List<List<Integer>> res, boolean[] flag) {
        if (cur.size() == nums.length) {
            res.add(new ArrayList<>(cur));
        } else {
            for (int i = 0; i < nums.length; i++) {
                if (flag[i] || (i > 0 && nums[i] == nums[i - 1] && !flag[i-1])) continue;
                cur.add(nums[i]);
                flag[i] = true;
                backtrack(nums, cur, res, flag);
                cur.remove(cur.size() - 1);
                flag[i] = false;
            }
        }
    }


    public static void main(String[] args) {
        int[] candidates = {1, 1, 5};
        System.out.println(new Solution().permuteUnique(candidates));
    }
}

39. Combination Sum

组合，元素无限制，和等于目标值

https://leetcode.com/problems/combination-sum/

/*
更好的形式
Runtime: 3 ms, faster than 78.07% of Java online submissions for Combination Sum.
        Memory Usage: 39.4 MB, less than 44.99% of Java online submissions for Combination Sum.
*/
public class SolutionV2 {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> r;
        r = new ArrayList<>();
        backtrack(target, 0, new ArrayList<>(), r, candidates);
        return r;
    }

    private void backtrack(int sum, int k, ArrayList<Object> cur, List<List<Integer>> result, int[] nums) {
        if(sum == 0) result.add(new ArrayList(cur));
        else if(sum < 0) return;
        else{
            for (int i = k; i < nums.length; i++) {
                cur.add(nums[i]);
                backtrack(sum - nums[i], i, cur, result, nums);
                cur.remove(cur.size() - 1);
            }
        }
    }
}

40. Combination Sum II

组合，求目标和，元素不重复

/*
集合选择框架版本
非常好的子集数实现。
算法复杂度，它的递归树是一个倾斜的递归树，实际上不好直接考虑，一个宽松的上界为元组可重复的版本，即使递归深度为target，
每个节点能选择的为N，因而为O(target ^ N)。从子集数来考虑，该问题的状态空间等于子集数数量，也就是O（2^N).
空间复杂度，递归深度等于O(N)，N为集合大小
Runtime: 3 ms, faster than 81.28% of Java online submissions for Combination Sum II.
        Memory Usage: 39.5 MB, less than 41.18% of Java online submissions for Combination Sum II.
*/

public class SolutionV2 {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, 0, new ArrayList<>(), res);
        return res;
    }

    private void backtrack(int[] nums, int sum, int k, ArrayList<Integer> cur, List<List<Integer>> res) {
        if(sum == 0) res.add(new ArrayList<>(cur));
        else if (sum < 0) return;
        else {
            for (int i = k; i < nums.length; i++) {
                // 防止组合重复的要点
                if (i > k && nums[i] == nums[i-1])continue;
                cur.add(nums[i]);
                backtrack(nums, sum - nums[i], i + 1, cur, res);
                cur.remove(cur.size() - 1);
            }
        }
    }
}

131 Palindrome Partitioning

切割字符串，使得所有切分都是回文，求所有可能

https://leetcode.com/problems/palindrome-partitioning/

/*
算法复杂度，这个问题本质上是子集数的问题，所以总共有O(2^N）个节点，每个节点需要O(N)
来判断是否是回文，所以时间复杂度为O(N 2^N)
空间复杂度为递归深度，O(N)
Runtime: 7 ms, faster than 85.32% of Java online submissions for Palindrome Partitioning.
        Memory Usage: 52.9 MB, less than 53.17% of Java online submissions for Palindrome Partitioning.
*/

public class SolutionV2 {

    public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>();
        backtrack(0, s, new ArrayList<String>(), res);
        return res;
    }

    private void backtrack(int k, String s, ArrayList<String> cur, List<List<String>> res) {
        if (k == s.length()) res.add(new ArrayList<>(cur));
        else {
            for (int i = k; i < s.length(); i++) {
                if (!isPalindrome(s, k, i)) continue;
                cur.add(s.substring(k, i+1));
                backtrack(i + 1, s, cur, res);
                cur.remove(cur.size() - 1);
            }
        }
    }

    private boolean isPalindrome(String sub, int low, int high) {
        for (; low < high; low++, high--)
            if (sub.charAt(low) != sub.charAt(high)) return false;
        return true;
    }
}

Ref

  • 全部灵感来自 https://leetcode.com/problems/combination-sum/discuss/16502/A-general-approach-to-backtracking-questions-in-Java-(Subsets-Permutations-Combination-Sum-Palindrome-Partitioning)
KDLin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
子集和（回溯法）
05-09
利用回溯法求子集和（给定sum，求出任意一个满足条件的集合）
回溯法-子集
FeNGQiHuALOVE的博客
01-17 147
怎么样写回溯法（从上而下，*代表难点，根据题目而变化） 画出递归树，找到状态变量（回溯函数的参数），这一步非常重要 * 根据题意，确定结束条件 找准选择列表（与函数参数相关），与第一步紧密关联 * 判断是否需要剪枝 做出选择，递归调用，进入下一层 撤销选择 构建递归树，如上图所示，选择列表里的数，都是选择路径（红色框）后面的数，使用一个参数start来标识当前的选择列表的起始位置。也就是标识每一层的状态，所以状态变量是起始位置。 找结束条件：start参数超过边界的时候，程序自己跳过下一层递归了，因
回溯法---子集和
chivalry
07-19 2116
http://blog.csdn.net/hustspy1990/article/details/6275725 /* 回溯法-子集和数问题 */ #include int M,n; int w[100]; int x[100]; void SumOfSub(int s, int k, int r)//w数组必须是递增的 { //s=w[1]*x[1]+...+w[k-1
(回溯法)求所有子集
长夜漫漫，无心睡眠
11-01 1772
相关数学知识：子集个数公式:n个元素就有2^n个子集，因为每个元素在子集中只有两种状态：有或没有 。 代码如下： 今天在研究最佳调度问题时突然加深理解了子集和回溯，其实dfs里else中的代码可以替换成如下代码，一样行得通。 for(int j=0;j<2;j++){//j代表有几种选择 x[i]=j; dfs(a,n,i+1,x); } import java.ut...
回溯法求所有子集
weixin_44021708的博客
12-18 586
给定一个整数数组nums，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。 解集不能包含重复的子集。你可以按任意顺序返回解集。 输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 输入：nums = [0] 输出：[[],[0]] package offer; import java.util.LinkedList; import java.util.List; public class 所...
回溯法求解子集和问题
12-26
回溯法是一种强大的算法策略，常用于解决组合优化问题，如子集和问题。这个问题的目标是从给定的一组整数中找出所有可能的子集，使得这些子集的元素和等于一个特定的目标值。在本案例中，我们将深入探讨如何使用回溯...
LeetCode 78题：子集 回溯法
01-21
题目分析：数组长度为n的数组的所有子集，其长度从0（空数组）到n（原数组）不等，因此我们可以使用回溯法来探寻不同长度子数组的所有可能性。 由于回溯法刚开始的时候理解起来有难度，所以我们首先来结合代码进行...
子集和数问题（回溯法）
11-17
给定N个数，和一个整数M，判定是否可以从N个数中取出若干个数，使它们的和等于M。输出：YES或者NO。把N个数看成一个集合，问题就是从这个集合中选出一个子集，使这个子集满足和是M
01背包问题回溯法解决子集树
11-10
在01背包问题中，回溯法构建了一个子集树，每个节点代表一个可能的物品选择状态。从根节点（空背包）开始，每层节点代表当前已经选取的物品，直到叶子节点（所有物品都被考虑过）。 以下是回溯法解决01背包问题的...
回溯算法-子集
jay_wonder的博客
06-04 490
一个集合的所有子集从空集开始，一直到自己本身，都是其子集 leetcode 78子集 没有重复元素集合的子集 同样的，套回溯模板 class Solution: def subsets(self, nums: List[int]) -> List[List[int]]: if not nums: return [[]] n = len(nums) res = [] def backtrace(start,
算法套路十——回溯法之子集型回溯
Pistachiout的学习博客
04-18 941
采用回溯法，用path记录当前数字选择的情况，ans记录答案。当前问题：数组前i-1个元素是否选择固定，枚举数组从第i个元素开始的所有元素是否选择当前操作：i是否为n，若是则将当前path加入ans中。若不是则需要枚举子集选择第i位元素或不选第i位元素，若不选第i位元素，则直接递归子问题；若选择第i位元素，则需要先将当前元素加入path中，并递归子问题，在递归完成后，进行回溯，将第i位元素从path中删除子问题：数组前i-1个元素是否选择固定，枚举数组从第i+1个元素开始的所有元素是否选择。
子集和----回溯法
wanwu_fusu的博客
10-29 257
#include&lt;iostream&gt; using namespace std; class ziji{ private:     int *s;     int *x;     int y;     int sum;     int *m;     int n; public:     void huisu(int t);     void Set(int n);     void I...
回溯法 子集和问题
fool宋的专栏
11-26 5543
问题描述 ： 子集和问题的一个实例为〈S,t 〉。其中，S={ X1 ，X2 ，…，Xn } 是一个正整数的集合，C是一个正整数。子集和问题判定是 否存在S 的一个子集S1 ，使得∑X (X∈S1) = C。 编程任务 ： 对于给定的正整数的集合S={ X1 ，X2 ，…，Xn } 和正整数C，编程计算S 的一个子集S1 ，使得∑X (X∈S1) = C。 数据输入 ： 第1行是2个正
回溯法实现求解子集合和问题
lzc534650799的博客
05-15 4644
1.回溯法简介   回溯法是一种在解空间搜索问题的解的方法。它在问题的解空间树种，按深度优先的策略，从根节点出发搜索解空间树。算法搜索至解空间树的任一节点时，先判断该节点是否包含问题的解。如果不包含，则跳过对以该节点为根的子树的搜索，逐层向其祖先节点回溯，否则进入该子树，继续按深度优先策略搜索。用回溯法求解问题的所有解的时，要回溯到根，且根节点的所有子树都被搜索遍才结束。用回溯法求问题的一个解时
回溯算法-定和子集问题
Xminyang的博客
10-28 3650
问题描述：在一给定集合中，选择出其子集，使得该子集的元素之和等于给定的数。选择的子集个数不一定唯一。 数学模型： 数的集合S={w1,w2,…,wn}; 定数：M; 求解向量: x=(x1,x2,…,xn)，xi为0或1, 使得wi*xi==M. 约束条件： 1、假定前k-1项选择已经确定，并且第k项已选择，使得wi*xi<=M; (i从1至k) 2、确定是否需要继续向前搜索
回溯法中子集树与排列树
波大菜菜
12-31 2541
回溯法 有许多问题，当需要找出它的解集或者要求回答什么解是满足某些约束条件的最优解时，往往使用回溯法。 回溯法的基本做法就是搜索，或者是一种能避免不必要搜索的暴力搜索法，这种方法适用于一些组合数相当大的问题。 回溯法在问题的解空间中，按深度优先策略，从根节点出发搜索解空间树，算法搜索到解空间中的任意一点时，首先进行判断该节点是不是包含问题的解，如果是不包含的，那么我们进行剪枝过程（就是跳过对该节点为
子集集合组合问题
lin的博客
08-13 314
题目 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。 说明：解集不能包含重复的子集。 示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ] 思路 回溯算法 代码 class Solution { public: vector<vector<int>> ans; int n; void backtrack(int firs
C++ 【回溯】如何在一组数中找到和为目标值的子集
weixin_46338206的博客
08-19 1457
组合数之和2 题目[leetcode40] 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。 示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [ [1, 7],[1, 2, 5],[2, 6],[1, 1, 6] ]
回溯算法解决路径总和
qq_34080360的博客
08-23 199
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { List<List<Integer>> result = new LinkedList&l...
回溯法解决子集和全排列
最新发布
04-30
回溯法是一种常用于解决组合问题的算法，可以用来解决子集和全排列问题。 对于子集和问题，可以使用回溯法来求解。具体步骤如下： 1. 定义一个数组来存储当前的子集，初始为空集。 2. 从原始数组的第一个元素开始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值