用递归实现如下问题：给定一个数组nums=[2，3，5]和一个固定的值target=8。找出数组nums中所有可以使数字和为target的组合（数字可重复）。

### 回答1：
我们可以使用递归实现以下问题：给定一个整数数组nums=[2,3,5]和一个固定的目标值target=8。找出nums中所有可能使用数字和为target的组合（数字可以重复使用）。

具体步骤如下：

1. 定义一个递归函数，该函数将有三个参数：当前正在考虑的数字的索引，当前的和以及解决方案的列表。

2. 如果当前的和等于目标值，将解决方案列表添加到全局解决方案列表中。

3. 如果当前的和大于目标值，则返回。

4. 从当前的数字开始逐个遍历。将当前数字添加到解决方案列表中，并递归调用函数，传递新的和和解决方案列表。

5. 在递归返回之后，从解决方案列表中移除添加的数字，回溯到之前的状态。

最后，返回全局解决方案列表。

实现代码可以参考下面的Python代码：

def combination_sum(nums, target):
    def backtrack(start, path, total):
        if total == target:
            res.append(path[:])
            return
        elif total > target:
            return
        for i in range(start, len(nums)):
            path.append(nums[i])
            backtrack(i, path, total+nums[i])
            path.pop()
    res = []
    backtrack(0, [], 0)
    return res

nums = [2,3,5]
target = 8
print(combination_sum(nums, target))

输出结果：

[[2, 2, 2, 2], [2, 3, 3], [3, 5]]

### 回答2：
递归是一种很常见也很重要的算法思想，能够解决很多问题，包括寻找数字的组合。本文将介绍如何使用递归实现如下问题：给定一个数组nums=[2，3，5]和一个固定的值target=8。找出数组nums中所有可以使数字和为target的组合（数字可重复）。

首先，我们可以使用递归函数来解决问题。递归函数的输入参数需要包含当前的和，已经添加了哪些数字以及目标数字。对于每个递归调用，我们需要遍历数组中的所有数字。如果当前数字加上当前和的结果等于目标数字，那么这条路径就找到一个符合要求的解。如果当前数字加上当前和的结果小于目标数字，那么递归调用将继续计算以当前数字开头的路径。如果当前数字加上当前和的结果大于目标数字，那么这个路径没有继续的必要。

在代码中，我们将使用一个list类型的path记录当前路径。我们还使用一个List类型的res记录所有符合要求的路径。以下是示例代码：

class Solution:
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res = []
        path = []
        candidates.sort()
        self.dfs(candidates, target, path, res)
        return res
    
    def dfs(self, candidates, target, path, res):
        if target == 0:
            res.append(path)
            return
        for i in range(len(candidates)):
            if target - candidates[i] < 0:
                break
            self.dfs(candidates[i:], target - candidates[i], path + [candidates[i]], res)

代码的基本思路是依次遍历数组中的所有数字，然后对每个数字递归调用函数。如果当前数字加上当前和等于目标数字，那么将当前路径添加到结果集中。如果当前数字加上当前和小于目标数字，那么递归调用继续计算下一层。如果当前数字加上当前和大于目标数字，那么终止当前路径的探索。递归深度是O(h)，其中h为路径的长度。在最坏情况下，即所有数字都选重复时，递归深度为O(n)。因此，时间复杂度为O(n*2^n)。空间复杂度为O(n)，即递归的深度。

### 回答3：
递归实现这个问题可以利用回溯法，即从数组的第一个元素开始遍历，判断当前元素是否能组成target，如果不能则回溯到上一步继续遍历。递归停止条件是target等于0，说明找到了一个符合条件的组合。

具体实现步骤如下：

1.定义一个递归函数，函数名为combinationSum，参数为当前数组的下标，当前组合的数字和total，当前组合的元素列表cur_list。

2.判断递归停止条件是否成立，即total是否等于0，如果成立，则输出结果。

3.在当前下标的基础上，遍历数组元素。

4.如果当前元素加上total大于target，则不能继续向下遍历。

5.如果当前元素加上total等于target，则找到了一个符合条件的组合，将当前元素加入cur_list，并输出结果。

6.如果当前元素加上total小于target，则将当前元素加入cur_list，继续递归调用combinationSum函数，更新total为total减去当前元素的值，下标为当前元素下标，cur_list为加入当前元素的列表。

7.递归调用结束后，将当前元素从cur_list中删除。

具体代码如下：

def combinationSum(nums, target):
    def dfs(cur_idx, total, cur_list):
        if total == 0:
            print(cur_list)
            return
        
        for i in range(cur_idx, len(nums)):
            if total - nums[i] < 0:
                break
            if total - nums[i] == 0:
                cur_list.append(nums[i])
                print(cur_list)
                cur_list.pop()
                break
            cur_list.append(nums[i])
            dfs(i, total - nums[i], cur_list)
            cur_list.pop()
    
    dfs(0, target, [])

输入nums=[2,3,5], target=8时，运行代码得到的输出结果如下：

[2, 2, 2, 2]
[2, 3, 3]
[3, 5]
[2, 2, 4]

说明数组nums中所有可以使数字和为target的组合为[2,2,2,2]、[2,3,3]、[3,5]和[2,2,4]。