学渣带你刷Leetcode0040组合总和 II

题目描述

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。 
示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

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

白话题目：

和39题太像了，就是有重复的数组了但是，每一个位置的数字不能用两次。

算法：

1,该题有重复元素，但是每个数字在组合中只能使用一次
2,在分支处理时使用 index+1 调用处理下一轮，则解决了每个数字在组合中只能使用一次的问题
3,保存当前节点数据时判断当前值是否已经回溯处理过，处理过则跳过，解决了重复元素导致结果重复的问题，避免了查重
4,优化了细节，1）在剪枝返回时，将当前保存值置0，2）在找到正确值，拷贝到下一轮时准确处理，已确保3判断正确，

详细解释关注 B站  【C语言全代码】学渣带你刷Leetcode 不走丢 https://www.bilibili.com/video/BV1C7411y7gB

C语言完全代码

#include <stdio.h>
#include <stdlib.h>
/**
 * 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().
 */
#define malloc_len  256
int compare(void *p1, void *p2)
{
    return *(int*)p1 - *(int*)p2;
}

int get_array_dfs(int **ret_array, int *ret_array_num, int *ret_col_size, int *candidates,
                  int candidatesSize, int target, int index, int col_pos)
{

    if (target == 0)
    {
        return 0; // 找到啦，返回给上层处理
    }
    if (target < 0)
    {
        return -1; // 本层没找到，没必要继续DFS，上层剪枝
    }
    int i;
    for ( i = index; i < candidatesSize; i++)
    {
          if (ret_array[*ret_array_num][col_pos] == candidates[i])
        {
            continue;
        }

        ret_array[*ret_array_num][col_pos] = candidates[i];
        //dfs处理

        int ret = get_array_dfs(ret_array, ret_array_num, ret_col_size, candidates, candidatesSize,
                                target - candidates[i], i+1, col_pos + 1);

        if (ret == 0)
        {
            //dfs找到了，记录下ret数据，拷贝到下个数组为下个数组的dfs做准备
            memcpy(&(ret_array[*ret_array_num + 1][0]), &(ret_array[*ret_array_num][0]),
                   sizeof(int) * (col_pos + 1));//目的、源、个数、

            ret_col_size[*ret_array_num] = col_pos + 1;
            (*ret_array_num)++;

            return 1;
        }
        if (ret == -1)
        {
            ret_array[*ret_array_num][col_pos] = 0;
            //由于从大到小排列，不需要再本层继续循环，直接返回上一层
            return 1;
        }
    }
     ret_array[*ret_array_num][col_pos] = 0;

    return 1;
}

int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)
{

    //1.初始化返回数组
    int **ret_array = malloc(sizeof(int*) * malloc_len);  //返回结果的二维数组

    int i;
    for ( i = 0; i < malloc_len; i++)
    {
        int *ret_col = malloc(sizeof(int) * malloc_len);   //定义返回的ret_col的大小   一个一维数组

        ret_array[i] = ret_col;
    }

    int col = 0;  //到底几组数
    int *col_size = malloc(sizeof(int) * malloc_len);

    //2. 排序
    qsort(candidates, candidatesSize, sizeof(int), compare);//数组，数组大小，元素大小，

    //结果数组，数组行数（个数），结果里面每行的大小，输入的数组，袁术数组大小，目标值，index，位置
    get_array_dfs(ret_array, &col, col_size, candidates, candidatesSize, target, 0, 0);

    //3. 返回题目所求
    *returnSize = col;
    *returnColumnSizes = col_size;  //一个一维数组
    return ret_array;
}

int main()
{
    int candidatesSize;
    printf("请输入数据大小\n");
    scanf("%d",&candidatesSize);

    int candidates[candidatesSize];
    int i;
    for(i=0; i<candidatesSize; i++)
    {
        scanf("%d",&candidates[i]);
    }
    printf("请输入目标值\n");
    int target;
    scanf("%d",&target);


    int returnSize=0;
    int j;
    int **returnColumnSizes=(int **)malloc(sizeof(int *) * 100);

    int **result=combinationSum(candidates,candidatesSize, target, &returnSize,  returnColumnSizes);

    for(i=0; i<returnSize; i++)
    {
        for(j=0; j<(*returnColumnSizes)[i]; j++)
        {
            printf("%d ",result[i][j]);
        }
        printf("\n");
    }

    return 0;
}