C语言力扣第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
    1 <= candidates[i] <= 200
    candidate 中的每个元素都 互不相同
    1 <= target <= 500

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析：

方法一：回溯法

根据示例 1：输入: candidates = [2, 3, 6, 7]，target = 7。

    候选数组里有 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
    同理考虑 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。

基于以上的想法，可以画出如下的树形图。建议大家自己在纸上画出这棵树，这一类问题都需要先画出树形图，然后编码实现。

编码通过 深度优先遍历 实现，使用一个列表，在 深度优先遍历 变化的过程中，遍历所有可能的列表并判断当前列表是否符合题目的要求，成为回溯算法。

• 以 target = 7 为 根结点 ，创建一个分支的时做减法 ；
• 每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 candidate 数组的每个元素的值；
• 减到 0 或者负数的时候停止，即：结点 0 和负数结点成为叶子结点；
• 所有从根结点到结点 0 的路径（只能从上往下，没有回路）就是题目要找的一个结果。

但只考虑这个会产生重复。

优化如下：从每一层的第 2 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。

 方法二：遍历法

遍历最重要的是确定遍历次数

本题其实可以想到如果能确定符合题意的组合的最大长度a，那么就可以用a次for循环搞定，而这个a是可以得到的，只要用target除以数组中的最小值就可得到理论上，组合的最大长度。然后又有一个问题那就是如何去写一个a次的for循环，递归可以做到，在for循环里用递归。最终的性能比回溯算法要慢

int *path;
int pathTop;
int **result;
int resultTop;
int *length;

void backTrack(int *candidates,int candidatesSize,int target, int sum , int index){
    if(sum>target)
        return ;
    if(sum == target){
        int *temp = malloc(sizeof(int)*pathTop);
        for(int i=0;i<pathTop;i++){
            temp[i] = path[i];
        }
        result[resultTop] = temp;
        length[resultTop++] = pathTop;
        return ;
    }
    for(int j=index; j<candidatesSize && sum<=target;j++){
        sum = sum + candidates[j];
        path[pathTop++] = candidates[j];
        backTrack(candidates,candidatesSize,target,sum,j);
        sum = sum - candidates[j];
        pathTop--;
    }
}

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    pathTop = resultTop = 0;
    path = malloc(sizeof(int)*100);
    result = malloc(sizeof(int*) *500);
    length = malloc(sizeof(int) *500);
    backTrack(candidates,candidatesSize,target,0,0);
    *returnSize = resultTop;
    *returnColumnSizes = malloc(sizeof(int) *500);
    for(int i =0 ; i<resultTop ; i++){
        (*returnColumnSizes)[i] = length[i];
    }
    return result;
}