代码解决

class Solution {
public:
    vector<int> res; // 当前组合的临时存储
    vector<vector<int>> result; // 存储所有符合条件的组合
    
    // 回溯函数
    void backtrcing(vector<int>& nums, int target, int flag, int index) {
        // 如果当前组合的和超过了目标值，则返回
        if (flag > target) return;
        
        // 如果当前组合的和等于目标值，则将当前组合加入结果集
        if (flag == target) {
            result.push_back(res);
            return;
        }
        
        // 遍历候选数组
        for (int i = index; i < nums.size(); i++) {
            flag += nums[i]; // 将当前元素加入组合和
            res.push_back(nums[i]); // 将当前元素加入当前组合
            backtrcing(nums, target, flag, i); // 递归调用回溯函数，允许重复使用当前元素
            flag -= nums[i]; // 回溯，移除当前元素
            res.pop_back(); // 回溯，移除当前元素
        }
    }
    
    // 主函数
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtrcing(candidates, target, 0, 0); // 初始调用回溯函数
        return result; // 返回所有符合条件的组合
    }
};

测试用例

输入

vector<int> candidates = {2, 3, 6, 7}; int target = 7;

输出

[ [2, 2, 3], [7] ]

过程描述

1. 初始状态：

   • candidates = {2, 3, 6, 7}
   • target = 7
   • res = []（当前组合为空）
   • result = []（所有符合条件的组合为空）

2. 递归回溯：

   • 从第一个元素 2 开始：
     • flag = 2，res = [2]，继续递归。
     • 再次选择 2：
       • flag = 4，res = [2, 2]，继续递归。
       • 再次选择 2：
         • flag = 6，res = [2, 2, 2]，继续递归。
         • 再次选择 2：
           • flag = 8，超过目标值，回溯，移除最后一个 2。
       • 尝试选择 3：
         • flag = 7，res = [2, 2, 3]，符合目标值，将组合加入 result，回溯，移除最后一个 3。
       • 尝试选择 6 和 7：
         • 超过目标值，回溯。
     • 尝试选择 3：
       • flag = 5，res = [2, 3]，继续递归。
       • 再次选择 3：
         • 超过目标值，回溯。
       • 尝试选择 6 和 7：
         • 超过目标值，回溯。
   • 尝试选择 3：
     • flag = 3，res = [3]，继续递归。
     • 再次选择 3：
       • flag = 6，res = [3, 3]，继续递归。
       • 尝试选择 3，6，7：
         • 超过目标值，回溯。
   • 尝试选择 6：
     • flag = 6，res = [6]，继续递归。
     • 尝试选择 6，7：
       • 超过目标值，回溯。
   • 尝试选择 7：
     • flag = 7，res = [7]，符合目标值，将组合加入 result。

最终，result 包含所有符合条件的组合 [[2, 2, 3], [7]]。