LeeCode 39.组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

复制代码

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

复制代码

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

复制代码

输入: candidates = [2], target = 1
输出: []

提示：

1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40

答案：

cpp 复制代码

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)

/**
 * 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** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes) { // LeeCode 39.组合总和
	// returnSize 存储返回的二维数组的长度。returnColumnSizes存储返回的二维数组中的每个数组的长度
	*returnSize = 0;
	if (target < 2) {
		return NULL;
	}
	*returnColumnSizes = (int*)malloc(150 * sizeof(int));
	if (*returnColumnSizes == NULL) {
		return NULL;
	}
	// candidates[i] >= 2, 所以临时数组长度最大为 target / 2 + 1
	int* temp = (int*) malloc((target / 2 + 1) * sizeof(int)); 
	if (!temp) return NULL;
	int** res = (int**) malloc(150 * sizeof(int*));
	if (!res) return NULL;
	zuhe(candidates, candidatesSize, target, 0, temp, 0, res, returnSize, returnColumnSizes);
	free(temp);
	return res;
}

// target为还差多少值， idx表示从哪个索引的数开始尝试（前面的数的各种情况已经尝试过了，不用再尝试）。
void zuhe(int* candidates, int candidatesSize, int target, int idx, int* temp, int tempSize, int** res, int* returnSize, int** returnColumnSizes) {
	if (target == 0) {
		// 已满足,保存结果
		int* arr_ = (int*)malloc(tempSize * sizeof(int));
		if (!arr_) return;
		memcpy(arr_, temp, tempSize * sizeof(int));
		*(res + *returnSize) = arr_;
		*(*returnColumnSizes + *returnSize) = tempSize;
		*returnSize = *returnSize + 1;
	}
	for (int i = idx; i < candidatesSize; i++) {
		if (candidates[i] > target) {
			continue;
		}
		// 可以加的情况,选中该数
		temp[tempSize++] = candidates[i];
		// 再递归选给临时数组下一位赋值。 注意，这里idx参数值必选传i，不能传idx，防止选到重复的组合。组合的临时数组中当前在选的数还可以选，但前面选过的数不能再选
		zuhe(candidates, candidatesSize, target - candidates[i], i, temp, tempSize, res, returnSize, returnColumnSizes);
		// 回退,不选这个数了
		tempSize--;
	}
}

测试代码：

cpp 复制代码

void printArr(int** arr, int size, int* returnColumnSizes);

void testLeeCode39(void) { // 组合总和
	int nums[] = { 2, 3, 6, 7 };
	int target = 7;
	int numsSize = 4;
	int returnSize; // 用于接受结果二维数组的长度。
	int* returnColumnSizes; // 用来接受结果二维数组的每个元素（即子数组）的长度
	int** res = combinationSum(nums, numsSize, target, &returnSize, &returnColumnSizes);
	printArr(res, returnSize, returnColumnSizes);

	// 释放内存
	for (int i = 0; i < returnSize; i++) {
		free(res[i]);
	}
	free(res);
	free(returnColumnSizes);
}

void printArr(int** arr, int size, int* returnColumnSizes) {
	printf("[");
	int isFirst = 1;
	for (int i = 0; i < size; i++) {
		if (isFirst) {
			isFirst = false;
		}
		else {
			printf(",");
		}
		int isSubFirst = 1;
		printf("[");
		for (int j = 0; j < returnColumnSizes[i]; j++) {
			if (isSubFirst) {
				isSubFirst = false;
			}
			else {
				printf(",");
			}
			printf("%d", arr[i][j]);
		}
		printf("]");
	}
	printf("]\n");
}

打印：

ok. 提交到LeeCode:

ok.