【算法与数据结构】39、LeetCode组合总和

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

一、39.组合总和解法

  思路分析：这道题当中数字可以多次使用，那么我们在递归语句当中不能直接找下一个candidate的元素，需要不断累加重复元素，直到它>=target，才能进入下一个循环，同时需要做剪枝优化，循环只在这个条件下进行sum+candidates[i] <= target。这道题的框架基于【算法与数据结构】216、LeetCode组合总和 III修改。

  程序如下：

class Solution {
private:
	vector<vector<int>> result;     // 结果合集
	vector<int> path;
	void backtracking(const vector<int>& candidates, const int target, int sum, int startIndex) {
		if (sum > target) return;    // 剪枝
		if (sum == target) {
			result.push_back(path);
			return;
		}
		for (int i = startIndex; i < candidates.size() && sum+candidates[i] <= target; i++) { // 剪枝优化
			sum += candidates[i];
			path.push_back(candidates[i]);  // 处理节点
			backtracking(candidates, target, sum, i);  // 递归
			sum -= candidates[i];
			path.pop_back();    // 回溯，撤销处理的节点
		}
	}
public:
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		vector<int> nums = candidates;		// 对candidates数组升排序
		sort(nums.begin(), nums.end());
		backtracking(nums, target, 0, 0);
		return result;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

复杂度分析：

• 时间复杂度： $O(n\ast 2^n)$， n为candidate大小。
• 空间复杂度：$O(target)$。

二、40.组合总和II解法

  思路分析：39.组合总和的基础之上，这道题变成了candidates中有重复元素，而且每个元素只能使用一次。如果直接使用39题的代码会出现重复的组合，需要去重，但这样一来leetcode可能运行超时。因此我们需要再找组合的时候就进行去重的操作。引入一个used布尔数组，标记candidates中的元素是否使用过。在这之前首先需要对candidates数组进行排序。

  例如， target=7, candidates = [1 1 2 4 5 7], 第一种情况：candidates[0] +candidates[2] + candidates[3] = candidates[1] +candidates[2] + candidates[3]= 1 + 2 + 4, 因此出现重复的组合。第二种情况：candidates[0] +candidates[1] + candidates[4]= 1 + 1 + 5是无重复的组合。因此用used标记使用过的数，当candidates[i] == candidates[i - 1]时，出现重复元素。进行第i次循环时，第一种情况used[i-1]=false就是出现重复组合, 在第i-1次循环时已经考虑过了，直接continue。第二种情况就是重复数字都利用到了used[i-1]=true，这种需要考虑。
  程序如下：

class Solution {
private:
	vector<vector<int>> result;     // 结果合集
	vector<int> path;
	
	void backtracking(const vector<int>& candidates, const int target, int sum, int startIndex, vector<bool>& used) {
		if (sum > target) return;    // 剪枝
		if (sum == target) {
			result.push_back(path);
			return;
		}
		for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) { // 剪枝优化
			if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {	// 去重
				continue; 
			}
			sum += candidates[i];
			used[i] = true;
			path.push_back(candidates[i]);  // 处理节点
			backtracking(candidates, target, sum, i+1, used);  // 递归
			used[i] = false;
			sum -= candidates[i];
			path.pop_back();    // 回溯，撤销处理的节点
		}
	}
public:
	vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
		vector<bool>used(candidates.size(), 0);
		sort(candidates.begin(), candidates.end());
		backtracking(candidates, target, 0, 0, used);
		return result;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

复杂度分析：

• 时间复杂度： $O(n\ast 2^n)$。
• 空间复杂度：$O(n)$。

三、完整代码

// 39.组合总和
# include 
# include 
# include 
# include 
using namespace std;

class Solution {
private:
	vector<vector<int>> result;     // 结果合集
	vector<int> path;
	void backtracking(const vector<int>& candidates, const int target, int sum, int startIndex) {
		if (sum > target) return;    // 剪枝
		if (sum == target) {
			result.push_back(path);
			return;
		}
		for (int i = startIndex; i < candidates.size() && sum+candidates[i] <= target; i++) { // 剪枝优化
			sum += candidates[i];
			path.push_back(candidates[i]);  // 处理节点
			backtracking(candidates, target, sum, i);  // 递归
			sum -= candidates[i];
			path.pop_back();    // 回溯，撤销处理的节点
		}
	}
public:
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		vector<int> nums = candidates;		// 对candidates数组升排序
		sort(nums.begin(), nums.end());
		backtracking(nums, target, 0, 0);
		return result;
	}
};

int main() {
	vector<int> candidates = { 2, 3, 6, 7 };
	int target = 7;
	Solution s1;
	vector<vector<int>> result = s1.combinationSum(candidates, target);
	for (vector<vector<int>>::iterator it = result.begin(); it != result.end(); it++) {
		for (vector<int>::iterator jt = (*it).begin(); jt != (*it).end(); jt++) {
			cout << *jt << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// 40.组合总和II
# include 
# include 
# include 
# include 
using namespace std;

class Solution {
private:
	vector<vector<int>> result;     // 结果合集
	vector<int> path;
	
	void backtracking(const vector<int>& candidates, const int target, int sum, int startIndex, vector<bool>& used) {
		if (sum > target) return;    // 剪枝
		if (sum == target) {
			result.push_back(path);
			return;
		}
		for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) { // 剪枝优化
			if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {	// 去重
				continue; 
			}
			sum += candidates[i];
			used[i] = true;
			path.push_back(candidates[i]);  // 处理节点
			backtracking(candidates, target, sum, i+1, used);  // 递归
			used[i] = false;
			sum -= candidates[i];
			path.pop_back();    // 回溯，撤销处理的节点
		}
	}
public:
	vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
		vector<bool>used(candidates.size(), 0);
		sort(candidates.begin(), candidates.end());
		backtracking(candidates, target, 0, 0, used);
		return result;
	}
};

int main() {
	vector<int> candidates = { 10,1,2,7,6,1,5 };
	int target = 8;
	Solution s1;
	vector<vector<int>> result = s1.combinationSum2(candidates, target);
	for (vector<vector<int>>::iterator it = result.begin(); it != result.end(); it++) {
		for (vector<int>::iterator jt = (*it).begin(); jt != (*it).end(); jt++) {
			cout << *jt << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

end