回溯算法-组合问题

最新推荐文章于 2024-06-15 16:17:24 发布
最新推荐文章于 2024-06-15 16:17:24 发布
阅读量620 收藏 16
点赞数 24
分类专栏： leetcode 文章标签： 算法 leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Richard/article/details/138031124
版权

回溯算法-组合问题

77. 组合

问题描述

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

  • 1 <= n <= 20
  • 1 <= k <= n

解题思路与代码实现

class Solution {

    private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果
    private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径

    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);    // 递归
        return res;
    }

    /**
     * 递归，纵向探索解空间树
     *
     * @param start 起始位置
     */
    private void backtracking(int n, int k, int start) {
        // path已存了k个元素，停止递归并合并结果
        if (path.size() == k) {
            // 使用深拷贝
            res.add(new ArrayList<>(path));
            return;
        }
        // for循环：横向枚举该层的所有可能，
        // 剪枝：例当n=4，k=3时，目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2
        for (int i = start; i <= n - (k - path.size()) + 1; i++) {
            path.addLast(i);
            backtracking(n, k, i+1);    // 递归
            path.removeLast(); // 回溯，撤销处理结果
        }
    }
}

踩坑点

如何进行剪枝优化

17. 电话号码的字母组合

问题描述

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

img

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

  • 1 <= n <= 20
  • 1 <= k <= n

解题思路与代码实现

class Solution {
    private static Map<String, String[]> map = new HashMap<>(); // 存储数字和字母的映射
    private List<String> res = new ArrayList<>();   // 保存最终结果

    static {
        // 初始化数字和字母的映射
        map.put("2", new String[]{"a", "b", "c"});
        map.put("3", new String[]{"d", "e", "f"});
        map.put("4", new String[]{"g", "h", "i"});
        map.put("5", new String[]{"j", "k", "l"});
        map.put("6", new String[]{"m", "n", "o"});
        map.put("7", new String[]{"p", "q", "r", "s"});
        map.put("8", new String[]{"t", "u", "v"});
        map.put("9", new String[]{"w", "x", "y", "z"});
    }

    public List<String> letterCombinations(String digits) {
        if (!digits.isEmpty()) {    // 字符串判空
            backtracking(digits, 0, new StringBuilder());
        }
        return res;
    }

    /**
     * 回溯函数
     * @param digits 数字字符串
     * @param index 当前层数字对应数字字符串中的下标
     * @param builder 动态字符串
     */
    private void backtracking(String digits, int index, StringBuilder builder) {
        if (builder.toString().length() == digits.length()) {   // 收集到digits.length()个字母
            // 合并结果
            res.add(builder.toString());
            return;
        }
        // 获取当成层对应的字母
        String[] letters = map.get(digits.charAt(index) + "");
        for (int i = 0; i < letters.length; i++) {
            builder.append(letters[i]); // 末尾拼接新的字母
            backtracking(digits, index + 1, builder);   // 递归
            builder.deleteCharAt(builder.length() - 1); // 移除末尾拼接的字母
        }
    }
}

踩坑点

无

39. 组合总和

问题描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

  • 1 <= candidates.length <= 30
  • 2 <= candidates[i] <= 40
  • candidates 的所有元素 互不相同
  • 1 <= target <= 40

解题思路与代码实现

class Solution {
    private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果
    private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径
    private int currentSum = 0; // path中的元素和

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);    // 升序排序
        backtracking(candidates, target, 0);
        return res;
    }

    /**
     * 回溯函数
     * 本题区别于组合总和，每层的节点都有n个分叉（n为candidates候选数组的长度）
     *
     * @param start 起始下标
     */
    private void backtracking(int[] candidates, int target, int start) {
        if (target == currentSum) {   // 收集到和为target的一组数
            // 合并结果(深拷贝)
            res.add(new ArrayList<>(path));
            return;
        }
        // 当前每层的节点都有n个分叉，代表candidates数组各个元素
        // 剪枝：如果 currentSum + candidates[i] > target 就终止遍历
        for (int i = start; i < candidates.length && currentSum + candidates[i] <= target; i++) {
            path.addLast(candidates[i]);
            currentSum += candidates[i];
            // 递归，起始下标为i有去重的效果，如样例1，计算出2,2,2后，不算重复计算3,2,2
            backtracking(candidates, target, i);
            currentSum -= candidates[i];    // 回溯
            path.removeLast();  // 回溯
        }
    }
}

踩坑点

需要设置变量记录当前path列表中的元素和

40. 组合总和 II

问题描述

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

**注意：**解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

解题思路与代码实现

class Solution {
    private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果
    private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径
    private int currentSum = 0; // path中的元素和

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);    // 升序排序
        backtracking(candidates, target, 0);
        return res;
    }


    /**
     * 回溯函数
     * 这道题目和39.组合总和 (opens new window)如下区别：
     * 1.本题candidates 中的每个数字在每个组合中只能使用一次。
     * 2.本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates
     * 踩坑：解空间树层去重：如用例candidates = [1,1,2,4]，target = 5，当i=0时，有[1,4]，当i=1时，无需在重复计算，跳过本轮循环（剪枝）
     * @param start 起始下标
     */
    private void backtracking(int[] candidates, int target, int start) {
        // currentSum>target不会执行if和for循环
        if (target == currentSum) {   // 收集到和为target的一组数
            // 合并结果(深拷贝)
            res.add(new ArrayList<>(path));
            return;
        }
        // 剪枝：如果 currentSum + candidates[i] > target 就终止遍历
        for (int i = start; i < candidates.length && currentSum + candidates[i] <= target; i++) {
            // 特别测试用例：1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 没有这一步可能会超时
            // 如果有相邻的重复元素，如candidates[i]== candidates[i - 1]，candidates[i-1]试过了则andidates[i]不需要重复计算，需要剪枝
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue;
            }
            path.addLast(candidates[i]);
            currentSum += candidates[i];
            // 递归，起始下标为i有去重的效果，避免重复计算
            backtracking(candidates, target, i + 1);
            currentSum -= candidates[i];    // 回溯
            path.removeLast();  // 回溯
        }
    }
}

踩坑点

重复元素需要避免重复计算，否则会超时

216. 组合总和 III

问题描述

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

  • 只使用数字1到9
  • 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

  • 2 <= k <= 9
  • 1 <= n <= 60

解题思路与代码实现

class Solution {
    private Integer currentSum = 0;    // 暂存path的元素和
    private List<List<Integer>> res = new ArrayList<>();    // 保存最终结果
    private LinkedList<Integer> path = new LinkedList<>();    // 暂存某一条解空间树中的路径

    /**
     * 找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
     * 只使用数字1到9
     * 每个数字 最多使用一次
     */
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(n, k, 1);
        return res;
    }

    /**
     * 递归，纵向探索解空间树
     *
     * @param start 起始位置
     */
    private void backtracking(int n, int k, int start) {
        // path已存了k个元素，停止递归并合并结果
        if (path.size() == k ) {
            if (currentSum == n){   // 和为n的才保存到结果中
                // 使用深拷贝
                res.add(new ArrayList<>(path));
            }
            return;
        }
        // for循环：横向枚举该层的所有可能，
        for (int i = start; i <= 9 && currentSum + i <= n; i++) {
            path.addLast(i);
            currentSum += i;
            backtracking(n, k, i + 1);    // 递归
            currentSum -= i;
            path.removeLast(); // 回溯，撤销处理结果
        }
    }
}

踩坑点

无

Mr_Richard
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++回溯算法实验报告
12-10
C++回溯算法实验报告，包括实验过程，实验代码，运行结果。
回溯算法解决组合问题
03-29
利用回溯算法解决组合问题。构造虚拟二叉树，采取深度优先搜索方式得到解。
leetcode 77 组合（c++）
m0_38071863的博客
01-17 386
### 题目 给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。 示例: 输入:n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] ### 思路 就是一个回溯法，然后返回条件改成i<=n-(k-temp.size())，这样可以减少很多计算，因为temp必要...
77. 组合 回溯法
小菜鸡
04-26 380
77. 组合 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] 示例 2： 输入：n = 1, k = 1 输出：[[1]] 思考 首先，这题是个求所有解问题- 回溯法。 注意:[3,1][1,3]算一个。 假设n=4，k=2时，回溯问题都可以抽象成树状结构如下图。 回溯所需要的参数有 int s
回溯(组合问题)
shiboluobuding的博客
03-04 472
回溯
Leetcode：77. 组合、216. 组合总和 III（C++）
Cosmoshhhyyy的博客
01-19 843
给定两个整数n和k，返回范围[1, n]中所有可能的k个数的组合。找出所有相加之和为n的k个数的组合，且满足下列条件：只使用数字1到9每个数字最多使用一次
回溯算法将组合问题一网打尽
p1967914901的博客
05-29 913
回溯算法将组合问题一网打尽 1. 组合 1.1 问题描述 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 1.2 要求 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ] 示例 2： 输入：n = 1, k = 1 输出：[[1]] 1.3 思路 既然是树形问题上的 深度优先遍历，因此首先画出树形结构。例如输入：n = 4,
回溯算法2：组合
Ge_yangwen的博客
02-16 180
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。
LeetCode题解回溯篇（TS版）
Leon_Chenl的博客
05-27 249
这是因为：即使把 5 选上，后面的数只有 6 和 7，一共就 3 个候选数，凑不出 4 个数的组合。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。如果至少一个数字的被选数量不同，则两种组合是不同的。的字符串，返回所有它能表示的字母组合。，用以表示一个 IP 地址，返回所有可能的。
数据结构与算法-回溯算法
06-13
以组合数问题为例，回溯算法通过递归和回溯的方式生成所有可能的组合，从而得到问题的解集。在n=5, r=3的情况下，算法能够列出所有从5个元素中选出3个元素的组合。同时，通过剪枝技术，算法可以在搜索过程中排除不...
回溯算法装载问题.doc
10-07
* 回溯算法的应用：回溯算法广泛应用于解决组合优化问题，例如装载问题、旅行商问题、排列问题等。 * Java 语言中的回溯算法实现：在 Java 语言中，我们可以使用递归函数来实现回溯算法，例如上述示例代码。 六、...
Python算法题源代码-LeetCode(力扣)-组合总和
02-29
39. 组合总和 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ， 并以列表形式返回。你可以按 任意顺序 返回这些组合。 ...
给定两个整数n和k，返回1 ... n中k个数的所有可能组合。
i_am_bird的博客
10-23 6588
本题源自leetcode ------------------------------------------------- 思路回溯法 vector > combine(int n, int k) { vector> result; if(nn) return result; vector path;
回溯算法|| 77. 组合
weixin_59340037的博客
02-07 455
回溯：组合问题
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 493
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 402
【代码】力扣LCP 08.剧情触发时间。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 682
LeetCode 算法：轮转数组c++
整数二分 个人见解
最新发布
shallrelow的博客
06-15 1216
整数二分
python回溯算法组合问题
12-07
回溯算法是一种通过不断尝试来找到所有解的算法。在组合问题中，我们需要从给定的n个数中找到所有可能的k个数的组合。以下是一个使用回溯算法解决组合问题的Python代码示例： ```python class Solution: def combine(self, n: int, k: int) -> List[List[int]]: if not n or not k: return None res = [] self.backtrack(n, [], res, k, 1) return res def backtrack(self, n, tmp, res, k, idx): if len(tmp) == k: res.append(tmp[:]) return for i in range(idx, n+1): tmp.append(i) self.backtrack(n, tmp, res, k, i+1) tmp.pop() ``` 在这个代码中，我们定义了一个Solution类，其中combine()方法接受两个参数n和k，分别表示从1到n的数字中选取k个数字的组合。backtrack()方法是实现回溯算法的核心部分，它通过递归的方式不断尝试添加数字，直到找到所有可能的组合。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值