LeetCode 39. Combination Sum

考点：回溯，递归

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

- All numbers (including target) will be positive integers.

- The solution set must not contain duplicate combinations.

For example, given candidate set [2, 3, 6, 7] and target 7,

A solution set is:

[

  [7],

  [2, 2, 3]

]

Java：

import java.util.*;

class Solution {

    List<List<Integer>> ans;

    List<Integer> currentNums;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {

        ans=new ArrayList<>();

        currentNums=new ArrayList<>();

        Arrays.sort(candidates);

        fun(candidates,target,0,0);

        return ans;

    }

    public void fun(int[] candidates,int target,int sum,int level)

    {

        if(sum>target)

            return;

        if(sum==target)

        {

            ans.add(new ArrayList<>(currentNums));

            return;

        }

        for(int i=level;i<candidates.length;i++)

        {

            sum+=candidates[i];

            currentNums.add(candidates[i]);

            fun(candidates,target,sum,i);

            sum-=candidates[i];

            currentNums.remove(currentNums.size()-1);

        }

    }

}

public class leetcode39

{

    public static void main(String args[])

    {

        Solution mySolution=new Solution();

        List<List<Integer>> ans;

        int target=7;

        int[] candidates={2,3,6,7};

        ans=mySolution.combinationSum(candidates,target);

        for(List<Integer> singleAns:ans)

        {

            for(Integer num:singleAns)

            {

                System.out.printf(num+" ");

            }

            System.out.println("");

        }

    }

}

C调试运行正确但是LeetCode上超时了，不知道怎么整了

#include <stdio.h>

#include <stdlib.h>

int maopao(int *candidates,int size)

{

    int i,j;

    for(i=size-1;i>=1;i--)

    {

        for(j=0;j<=i;j++)

        {

            if(candidates[j]>candidates[j+1])

            {

                int temp;

                temp=candidates[j];

                candidates[j]=candidates[j+1];

                candidates[j+1]=temp;

            }

        }

    }

    return 0;

}

int fun(int *candidates,int candidatesSize,int target,int **ret,int *currentColumn,int *currentColumnSize,int **columnSizes,int *returnSize,int *currentSum,int level,int *flag)

{

    int i;

    if(*currentSum>target)

    {

       // (*currentColumnSize)--;

        //(*currentSum)-=(*(currentColumn+(*currentColumnSize)));

        *flag=1;

        return 0;

    }

    if(*currentSum==target)

    {

        //保存当前结果

        int *currentNums;

        currentNums=(int *)malloc(sizeof(int)*(*currentColumnSize));

        for(i=0;i<(*currentColumnSize);i++)

            currentNums[i]=currentColumn[i];

        *(ret+(*returnSize))=currentNums;

        //保存当前解的大小

        *(*(columnSizes)+(*returnSize))=(*currentColumnSize);

        (*returnSize)++;

        *flag=1;

       // (*currentColumnSize)--;

       // (*currentSum)-=(*(currentColumn+(*currentColumnSize)));

        return 0;

    }

    for(i=level;i<candidatesSize;i++)

    {

        (*currentSum)+=(*(candidates+i));

        *(currentColumn+(*currentColumnSize))=(*(candidates+i));

        (*currentColumnSize)++;

        fun(candidates,candidatesSize,target,ret,currentColumn,currentColumnSize,columnSizes,returnSize,currentSum,i,flag);

        (*currentColumnSize)--;

        (*currentSum)-=(*(candidates+i));

        if(*flag==1)

        {

            *flag=0;

            break;

        }

    }

    return 0;

}

int** combinationSum(int* candidates, int candidatesSize, int target, int** columnSizes, int* returnSize) {

    int **ret;

    int currentSum=0;

    int *currentColumn;

    int *currentColumnSize;

    currentColumnSize=(int *)malloc(sizeof(int));

    int flag=0;

    *currentColumnSize=0;

    currentColumn=(int *)malloc(sizeof(int)*1000);

    *columnSizes=(int *)malloc(sizeof(int)*1000);

    ret=(int **)malloc(sizeof(int *)*1000);

    *returnSize=0;

    maopao(candidates,candidatesSize);

    fun(candidates,candidatesSize,target,ret,currentColumn,currentColumnSize,columnSizes,returnSize,&currentSum,0,&flag);

    return ret;

}

int main()

{

    int i,j;

    int candidates[4]={2,3,9,7};

    int candidatesSize=4;

    int target=7;

    int *columnSizes;

    int returnSize;

    int **ret;

    ret=combinationSum(candidates,candidatesSize,target,&columnSizes,&returnSize);

    for(i=0;i<returnSize;i++)

    {

        for(j=0;j<*(columnSizes+i);j++)

        {

            printf("%d ",ret[i][j]);

        }

        printf("\n");

    }

    return 0;

}