LeetCode39-组合总和

LeetCode39-组合总和

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

candidates 中的数字可以无限制重复被选取。

说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。

示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

示例 2:

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

一、思路

（一）直接想法

先看看有几类方法可以凑成target 的值：
（1）数组中存在target的因子
（2）数组中能凑出target的因子
（3）非因子，但是相加等于target
（4）因子+非因子=target

根据以上想法，写出算法流程：
（1）分解target，求得所有因子
（2）计算数组中与因子相等或者，相加等于因子

等等这一步就很复杂了，尤其是因子比较大的时候，这么一来时间复杂度会很高

换个思路，先对数组排序，得到一个有序的数组，从最小的开始算起，寻找target的因子，直到数组中取出的值大于$\frac{target}{2}$，这步操作对应于（1）

但是第二步的问题很大，两个数来凑还是三个数来凑，又或者是n个数来凑，此时重复选用的元素实在是太多了，效率低下，放弃这个方法

（二）方法选择

先来看看这个问题的形式：
$n_1+n_2+n_3.....+n_i=target$
在这个问题中不存在局部最优解，因此无法使用贪心算法，但是这个形式和回溯算法有点像

如果选择回溯算法，那么算法流程：
（1）排序
（2）从最大的开始，相加，若大于target则回溯，使用更小的数
（3）若等于target，保存后再回溯

这个方法有个漏洞，就是会出现重复的向量，因此需要利用set来进行去重，在插入集合之前，对向量进行排序，再插入，就可以去重了。

C++代码：

class Solution {
public:
	set<vector<int>> results;
	int t;
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		t = target;
		if (candidates.empty())
			return vector<vector<int>>(results.begin(), results.end());

		sort(candidates.begin(), candidates.end());
		if (candidates[0] > target)
			return vector<vector<int>>(results.begin(), results.end());

		vector<int> res;
		recall(candidates, candidates.size() - 1, 0, res);

		return vector<vector<int>>(results.begin(), results.end());
	}
	void recall(vector<int>& candidates, int cur, int sum, vector<int> res) {
		if (sum == t) {
			sort(res.begin(), res.end());
			results.insert(res);
			return;
		}

		if (sum > t)
			return;

		for (int i = cur; i >= 0; i--) {
			sum += candidates[i];
			res.push_back(candidates[i]);
			recall(candidates, cur, sum, res);
			res.pop_back();
			sum -= candidates[i];
		}
	}
};

执行效率：

效率很低，可以看出插入之前排序确实不是个好方法，那么有没有别的办法去重呢？

（三）改进去重

改进的依据：由于每次回溯时，都是要找一个小于或者等于上一个向量元素的数，因此可知，在向量里面，是严格的按非升序排序的

C++代码：

class Solution {
public:
	set<vector<int>> results;
	int t;
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		t = target;
		if (candidates.empty())
			return vector<vector<int>>(results.begin(), results.end());

		sort(candidates.begin(), candidates.end());
		if (candidates[0] > target)
			return vector<vector<int>>(results.begin(), results.end());

		vector<int> res;
		recall(candidates, candidates.size() - 1, 0, res);

		return vector<vector<int>>(results.begin(), results.end());
	}
	void recall(vector<int>& candidates, int cur, int sum, vector<int> res) {
		if (sum == t) {
			//sort(res.begin(), res.end());
			results.insert(res);
			return;
		}

		if (sum > t)
			return;

		for (int i = cur; i >= 0; i--) {
			if (!res.empty() && candidates[i] > res.back())
				continue;
			sum += candidates[i];
			res.push_back(candidates[i]);
			recall(candidates, cur, sum, res);
			res.pop_back();
			sum -= candidates[i];
		}
	}
};

执行效率：