40. 组合总和 II （C语言）

40. 组合总和 II

int compare(int *a,int*b){
    return (*a)-(*b);
}
typedef struct stackNode{
    int val;
    struct stackNode *next;
}stackNode;
typedef struct stack{
    int len;
    stackNode* top;
}stack;

stack *create(){
    stack *s=malloc(sizeof(*s));
    s->len=0;
    s->top=NULL;
    return s;
}
void push(stack* s,int val){
    stackNode *n=malloc(sizeof(*n));
    n->val=val;
    n->next=NULL;
    if(s->len==0){
        s->top=n;
        s->len++;
        return;
    }
    n->next=s->top;
    s->top=n;
    s->len++;
}
void pop(stack *s){
    if(s->len==0)return;
    s->top=s->top->next;
    s->len--;
}
#define MAXSIZE 500
void DFS(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes,stack *s,int **ret,int start);
int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    if (candidates == NULL) {
        return NULL;
    }
    *returnSize = 0;
    *returnColumnSizes = (int *)calloc(sizeof(int), MAXSIZE);
    int** ret = (int **)calloc(sizeof(int), MAXSIZE);
    stack* s = create();
    qsort(candidates, candidatesSize, sizeof(int), compare);
    DFS(candidates, candidatesSize, target, returnSize, returnColumnSizes, s, ret, 0);
    return ret;
}

void DFS(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes,stack *s,int **ret,int start){
    if(target==0){
        int t=s->len;
        ret[*returnSize]=malloc(sizeof(int)*t);
        (*returnColumnSizes)[*returnSize]=t;
        stackNode*p=s->top;
        for(int i=t-1;i>=0;i--)
        {
            ret[*returnSize][i]=p->val;
            p=p->next;
        }
        (*returnSize)++;
        return;
    }
    for(int i=start;i<candidatesSize;i++)
    {
        if (target < candidates[i]) {
            break;
        }
        if (i > start && candidates[i] == candidates[i - 1])
            continue;


        push(s,candidates[i]);
        DFS(candidates,candidatesSize,target-candidates[i],returnSize,returnColumnSizes,s,ret,i+1);
        pop(s);
    }
}

回溯法 

int compare(int *a,int*b){
    return (*a)-(*b);
}
int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    qsort(candidates,candidatesSize,sizeof(int),compare);
    int **ret=malloc(sizeof(int*)*1000);
    int *temp=malloc(4000);
    (*returnColumnSizes)=(int*)malloc(sizeof(int)*500);
    *returnSize=0;
    backtrack(ret,candidates,candidatesSize,target,0,returnSize,returnColumnSizes,temp,0,0);
    return ret;
}
void backtrack(int **ret,int* candidates, int candidatesSize, int target,int sum, int* returnSize, int** returnColumnSizes,int *temp,int t,int i){
    if(i>candidatesSize-1)return;
    temp[t]=candidates[i];
    sum=sum+candidates[i];
    if(sum>target)return;
    else if(sum==target){
        ret[*returnSize]=malloc(sizeof(int)*(t+1));
        (*returnColumnSizes)[*returnSize]=t+1;
        ret[*returnSize]=memcpy(ret[*returnSize],temp,sizeof(int)*(t+1));
        (*returnSize)++;
        //printf("t= %d,temp[i]=%d,sum=%d\n",t,temp[t],sum);
        return;
    }

    //printf("i= %d,candidate[i]=%d,sum=%d\n",i,candidates[i],sum);

    backtrack(ret,candidates,candidatesSize,target,sum,returnSize,returnColumnSizes,temp,t+1,i+1);
while(i<candidatesSize-1&&candidates[i]==candidates[i+1])i++;//选i。
    backtrack(ret,candidates,candidatesSize,target,sum-candidates[i],returnSize,returnColumnSizes,temp,t,i+1); //不选i。
}