【LeetCode-216】组合总和 III

最新推荐文章于 2026-06-20 21:44:23 发布

原创最新推荐文章于 2026-06-20 21:44:23 发布 · 638 阅读

27 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#数据结构 #leetcode

数据结构专栏收录该内容

24 篇文章

订阅专栏

🎉 关注“青柠代码录”公众号，🔥更多精彩内容持续更新中🔥，快来加入我们吧！🚀

LeetCode题目链接：

216. 组合总和 III - 力扣（LeetCode）

📝 文章摘要

本文将详细讲解如何解决“找出所有相加之和为 n 的 k 个数的组合”这一经典算法问题。

我们将从解题思路入手，逐步剖析回溯算法的核心思想，并通过清晰的代码实现和详细的案例执行过程，帮助读者深入理解每一步的逻辑。

🔍 解题思路

1. 题目分析

我们需要找到所有满足以下条件的组合：

使用数字 1 到 9；
每个数字最多使用一次；
组合长度为 k；
组合中数字的和为 n。

2. 核心算法：回溯法

回溯法是一种经典的递归算法，适用于求解组合、排列等问题。其基本思想是：

选择：从候选集中选择一个元素；
探索：基于当前选择继续递归；
撤销选择：如果当前路径不满足条件，则回退到上一步。

在本题中，我们可以通过以下步骤实现回溯：

定义状态变量：

当前组合（路径）；
剩余需要选择的数字数量（k）；
剩余的目标和（n）。

剪枝优化：

如果剩余目标和小于 0，直接返回；
如果剩余数字数量大于可用数字范围，直接返回。

终止条件：

当组合长度等于 k 且目标和为 0 时，记录结果。

🧩 案例执行过程

案例 1：输入 `k = 3, n = 7`

步骤 1：初始化

起始状态：

当前组合为空列表 []；
候选数字集合为 [1, 2, 3, 4, 5, 6, 7, 8, 9]；
剩余数字数量 k = 3；
剩余目标和 n = 7。

步骤 2：递归展开

选择数字 1：

更新状态：
- 当前组合为 [1]；
- 剩余数字数量 k = 2；
- 剩余目标和 n = 6。

继续递归。

选择数字 2：

更新状态：
- 当前组合为 [1, 2]；
- 剩余数字数量 k = 1；
- 剩余目标和 n = 4。

继续递归。

选择数字 4：

更新状态：
- 当前组合为 [1, 2, 4]；
- 剩余数字数量 k = 0；
- 剩余目标和 n = 0。

满足条件，记录结果 [1, 2, 4]。

步骤 3：回溯

回退到上一层，尝试其他可能的组合。

最终结果为：[[1, 2, 4]]。

案例 2：输入 `k = 3, n = 9`

按照类似的过程，可以得到以下组合：

[1, 2, 6]
[1, 3, 5]
[2, 3, 4]

最终结果为：[[1, 2, 6], [1, 3, 5], [2, 3, 4]]。

🖥️ Java 代码实现

以下是完整的 Java 实现代码：

import java.util.*;

class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        // 结果列表
        List<List<Integer>> result = new ArrayList<>();
        // 当前组合路径
        List<Integer> path = new ArrayList<>();
        // 调用回溯函数
        backtrack(k, n, 1, path, result);
        return result;
    }

    /**
     * 回溯函数
     * @param k 剩余需要选择的数字数量
     * @param n 剩余的目标和
     * @param start 当前候选数字的起始位置
     * @param path 当前组合路径
     * @param result 结果列表
     */
    private void backtrack(int k, int n, int start, List<Integer> path, List<List<Integer>> result) {
        // 终止条件：组合长度为 k 且目标和为 0
        if (k == 0 && n == 0) {
            result.add(new ArrayList<>(path)); // 记录当前组合
            return;
        }
        // 剪枝条件：剩余数字不足或目标和小于 0
        if (k <= 0 || n < 0) {
            return;
        }

        // 遍历候选数字
        for (int i = start; i <= 9; i++) {
            // 选择数字 i
            path.add(i);
            // 递归调用
            backtrack(k - 1, n - i, i + 1, path, result);
            // 撤销选择
            path.remove(path.size() - 1);
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        // 测试案例 1
        System.out.println("案例 1 输出: " + solution.combinationSum3(3, 7));
        // 测试案例 2
        System.out.println("案例 2 输出: " + solution.combinationSum3(3, 9));
        // 测试案例 3
        System.out.println("案例 3 输出: " + solution.combinationSum3(4, 1));
    }
}

📊 可视化表示

回溯过程树形结构

以 k = 3, n = 7 为例，构建回溯过程的树形结构：

深色版本

根节点 []
├── 选择 1 → [1]
│   ├── 选择 2 → [1, 2]
│   │   └── 选择 4 → [1, 2, 4] ✅
│   └── 选择 3 → [1, 3] ❌
└── 选择 2 → [2] ❌

📚 总结

通过本文的详细讲解，我们学习了如何利用回溯算法解决“找出所有相加之和为 n 的 k 个数的组合”问题。希望本文能够帮助读者更好地理解回溯法的核心思想，并在实际编程中灵活运用。如果有任何疑问，欢迎留言交流！🌟