组合总数--回溯+剪枝

组合总和。
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
例：
candidates = [2,3,6,7], target = 7,
[
[7],
[2,2,3]
]
candidates = [2,3,5], target = 8,
[
[2,2,2,2],
[2,3,3],
[3,5]
]

 

回溯算法框架：
rs=[]
def backtrack(路径，选择列表):
    if 满足结束条件：
        rs.add(路径)
        return

    for 选择 in 选择列表：
        做选择
        backtrack(路径，选择列表)
        撤销选择

全排列模板：permutation p(n,d)
p(nums,d,n,used,curr,ans):
    if d==n:
        ans.append(curr);
        return
    for i=0 to len(nums):
        if used[i]:continue
        used[i]=True
        curr.push(nums[i])
        p(nums,d+1,n,curr,ans)
        curr.pop()
        used[i]=False

组合模板：--特点，后面的数都比前面的数大！--不重复（所以递归为i+1）;可以重复（递归为i）
combination c(n,d)
c(nums,d,n,s,curr,ans):
    if d==n:
        ans.append(curr);
        return
    for i=s to len(nums):
        curr.push(nums[i])
        c(nums,d+1,n,i+1,curr,ans)
        curr.pop()

 

/*
组合总和。
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
例：
candidates = [2,3,6,7], target = 7,
[
  [7],
  [2,2,3]
]
candidates = [2,3,5], target = 8,
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]
*/
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include <iostream>
int compare(const void *a,const void *b){
    return *(int*)a-*(int*)b;
}
void dfs(int* candidates, int candidatesSize,int start,int target,int** rs,int* returnSize,int** returnColumnSizes,int *path,int pathlenth,int dpth,int n){
    int i;
    if(dpth==n){
        if(target==0){
            rs[*returnSize] = (int*)malloc(sizeof(int)*pathlenth);
            for(i=0;i<pathlenth;i++){
                printf("%d ",path[i]);
                rs[*returnSize][i]=path[i];
            }
            returnColumnSizes[0][*returnSize]=pathlenth;
            (*returnSize)++;
        }
    }

    for(i=start;i<candidatesSize;i++){
        if(target<candidates[i])
            break;
        path[pathlenth]=candidates[i];
        dfs(candidates,candidatesSize,i,target-candidates[i],rs,returnSize,returnColumnSizes,path,pathlenth+1,dpth+1,n);
    }
}
int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){

    qsort(candidates,candidatesSize,sizeof(int),compare);

    int** rs=(int**)malloc(sizeof(int*)*200);

    returnColumnSizes[0]=(int*)malloc(sizeof(int)*200);

    int *path=(int*)malloc(sizeof(int)*10),pathlenth=0,n;
    *returnSize=0;

    for(n=1;n<=target/candidates[0];n++){
        printf("%d\n",target/candidates[0]);
        dfs(candidates,candidatesSize,0,target,rs,returnSize,returnColumnSizes,path,pathlenth,0,n);
    }

    return rs;
}
int main()
{
    int candidates[]={2,3,6,7},target=7,*returnSize,**returnColumnSizes;
    returnSize=(int*)malloc(sizeof(int)*100);
    returnColumnSizes=(int**)malloc(sizeof(int*)*100);
    int **rs=combinationSum(candidates,4,target,returnSize,returnColumnSizes);

    return 0;
}