力扣------子集 II

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** subsetsWithDup(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    *returnSize=0;
    int flag=0;
    int d;
    int sum[21]={0};
    int sum1[21]={0};
    *returnColumnSizes=(int*)calloc(10000,sizeof(int));
    int** ans=(int**)calloc(10000,sizeof(int*));
    (*returnColumnSizes)[*returnSize]=0;
    *returnSize=*returnSize+1;
    for(int a=0;a<numsSize;a++){
        ans[*returnSize]=(int*)calloc(10,sizeof(int));
        ans[*returnSize][0]=nums[a];
        (*returnColumnSizes)[*returnSize]=1;
        for(int e=1;e<=*returnSize-1;e++){
            if((*returnColumnSizes)[e]==1){
                if(ans[e][0]==nums[a]){
                    flag=1;
                }
            }
        }
        if(flag==0){
            *returnSize=*returnSize+1;
            d=*returnSize;
        }
        else{
            d=*returnSize+1;
        }
        flag=0;
        for(int b=1;b<d-1;b++){
            ans[*returnSize]=(int*)calloc(10,sizeof(int));
            for(int c=0;c<(*returnColumnSizes)[b];c++){
                ans[*returnSize][c]=ans[b][c];
            }
            ans[*returnSize][(*returnColumnSizes)[b]]=nums[a];
            (*returnColumnSizes)[*returnSize]=(*returnColumnSizes)[b]+1;
            int flag1=0;
            for(int e=1;e<=*returnSize-1;e++){
                flag=0;
                for(int g=0;g<21;g++){
                    sum[g]=0;
                    sum1[g]=0;
                }
                if((*returnColumnSizes)[e]==(*returnColumnSizes)[*returnSize]){
                    for(int f=0;f<(*returnColumnSizes)[e];f++){
                        if(ans[e][f]>=0){
                            sum[ans[e][f]]=sum[ans[e][f]]+1;
                        }
                        else{
                            sum[ans[e][f]*(-1)+10]=sum[ans[e][f]*(-1)+10]+1;
                        }
                        if(ans[*returnSize][f]>=0){
                            sum1[ans[*returnSize][f]]=sum1[ans[*returnSize][f]]+1;
                        }
                        else{
                            sum1[ans[*returnSize][f]*(-1)+10]=sum1[ans[*returnSize][f]*(-1)+10]+1;
                        }
                    }
                    for(int h=0;h<21;h++){
                        if(sum[h]==sum1[h]){
                            flag++;
                        }
                    }
                    if(flag==21){
                        flag1=1;
                        break;
                    }
                }
            }
            if(flag1==0){
                *returnSize=*returnSize+1;
            }
            flag1=0;
        }
    }
    return ans;
}