leetcode中有几个求sum的问题，思路基本上一样，在这里一并列出。
这几道题主要思路是在使用双指针解决2SUM的基础上，将kSUM逐步reduce到2SUM。 大致框架如下：
1) sort
2) repeatedly reduce kSUM to k-1SUM, until 2SUM
3) solve 2SUM
那么问题就变成了怎样解决2SUM。这里2SUM描述成：
“Given an sorted array of integers, find two numbers such that they add up to a specific target number”
如前所述，解决这个问题要用两个pointer，start和end，分别从数组两边向中间扫描，
if Array[start] + Array[end] > target, end--;
if Array[start] + Array[end] < target, start++;
if Array[start] + Array[end] = target, add Array[start] and Array[end] to the result set;
有时为了去掉重复元素（如 {2,2,3,5}，这里第一个2和第二个2是重复的，有时只需要考虑一个就可以），每次在比较完Array[start] + Array[end]和target的大小后，要分别加上（具体用法见3SUM的code）
while(Array[start - 1] == Array[start] && start < end) start++;
while(Array[end + 1] == Array[end] && end > start) end--;
好了，这几道题的主体思路有了，我们一道一道看。
TWO SUM： https://leetcode.com/problems/two-sum/
这道题和我们在上面描述的2SUM问题有三点不同，第一是这道题输入数组没有排序，第二是这道题需要返回index，第三是这道题不需要去重。
首先我们根据上面的思路来做，先sort。但是由于结果要返回index，所以排序之前先保存一下之前的数组，最后再回来找index。之后再双指针两边扫描。时间上需要O(nlogn)， 空间上需要O(n)。代码如下
class Solution {
public:
vector<int> twoSum(vector<int> &numbers, int target) {
vector<int> ori = numbers;
sort(numbers.begin(), numbers.end());
int start = 0, end = numbers.size() - 1;
while(start < end) {
if(numbers[start] + numbers[end] < target)
start++;
else if(numbers[start] + numbers[end] > target)
end--;
else
break;
}
vector<int> res;
for(int i = 0; i < ori.size(); i++) {
if(ori[i] == numbers[start] || ori[i] == numbers[end])
res.push_back(i + 1);
}
return res;
}
};
不过2sum这道题还有一个方法就是用hashtable把所有过往元素都存下来，这样time complexity是O(n)， space也是O(n)，但由于这种方法并不适合用于解决k>=3的问题，这里不做过多的讲解，详细解释可以看leetcode官方给出的solution。代码如下
class Solution {
public:
vector<int> twoSum(vector<int> &numbers, int target) {
unordered_map<int, int> visited;
vector<int> res;
for(int i = 0; i < numbers.size(); i++) {
if(visited.find(target - numbers[i]) == visited.end()) {
visited.insert(make_pair(numbers[i], i));
}
else {
res.push_back(visited[target - numbers[i]] + 1);
res.push_back(i + 1);
return res;
}
}
return res;
}
};
3SUM：https://leetcode.com/problems/3sum/
这道题就是根据之前说的框架，先sort，然后reduce，然后用2SUM处理。这里的reduce很直接了，就是依次把数组中每一个元素值的负值作为2SUM中的target，start每次从当前target元素的下一个开始即可。注意代码中的去重部分。这样子O(n^2)的时间。
class Solution {
public:
vector<vector<int> > threeSum(vector<int> &num) {
vector<vector<int> > res;
sort(num.begin(), num.end());
int i = 0;
while(i < num.size()) {
int target = 0 - num[i];
int start = i + 1, end = num.size() - 1;
while(start < end) {
if(num[start] + num[end] < target) {
start++;
//去重
while(start < end && num[start - 1] == num[start])
start++;
}
else if(num[start] + num[end] > target) {
end--;
//去重
while(start < end && num[end + 1] == num[end])
end--;
}
else {
vector<int> re;
re.push_back(num[i]);
re.push_back(num[start]);
re.push_back(num[end]);
res.push_back(re);
start++;
end--;
//去重
while(start < end && num[start - 1] == num[start])
start++;
while(start < end && num[end + 1] == num[end])
end--;
}
}
i++;
//去重
while(i < num.size() && num[i - 1] == num[i])
i++;
}
return res;
}
};
3SUM Closest: https://leetcode.com/problems/3sum-closest/
这道题和上一道思路几乎一样，区别是返回的要求不同而已。时间也是O(n^2)。
class Solution {
public:
int threeSumClosest(vector<int> &num, int target) {
sort(num.begin(), num.end());
int close = num[0] + num[1] + num[2];
int i = 0;
while(i < num.size()) {
int start = i + 1, end = num.size() - 1;
while(start < end) {
int sum = num[start] + num[end] + num[i];
close = abs(close - target) < abs(sum - target) ? close : sum;
if(sum < target) {
start++;
while(start < end && num[start - 1] == num[start])
start++;
}
else if(sum > target) {
end--;
while(start < end && num[end + 1] == num[end])
end--;
}
else
return close;
}
i++;
while(i < num.size() && num[i - 1] == num[i])
i++;
}
return close;
}
};
4SUM：https://leetcode.com/problems/4sum/
这个系列的最后一道题，但是思路并没有变化，只是需要从4SUM reduce to 2SUM。
class Solution {
public:
vector<vector<int> > fourSum(vector<int> &num, int target) {
sort(num.begin(), num.end());
vector<vector<int> > res;
for(int i = 0; i < num.size(); i++) {
for(int j = i + 1; j < num.size(); j++) {
int start = j + 1, end = num.size() - 1;
while(start < end) {
int sum = num[i] + num[j] + num[start] + num[end];
if(sum < target) {
start++;
while(start < end && num[start - 1] == num[start])
start++;
}
else if(sum > target) {
end--;
while(start < end && num[end + 1] == num[end])
end--;
}
else {
vector<int> re(4,0);
re[0] = num[i];
re[1] = num[j];
re[2] = num[start];
re[3] = num[end];
res.push_back(re);
start++;
end--;
while(start < end && num[start - 1] == num[start])
start++;
while(start < end && num[end + 1] == num[end])
end--;
}
}
while(j + 1 < num.size() && num[j] == num[j + 1])
j++;
}
while(i + 1 < num.size() && num[i] == num[i + 1])
i++;
}
return res;
}
};
如果kSUM的话，需要使用backtracking。这个问题本身是NP-hard的。
更正：
之前说的基本思路的确是可行的，而且对于kSUM=target, kSUM<target, kSUM>target （比如3SUM closest） 都适用。但是2SUM的hashtable方法在k是偶数的时候可以提高效率，只是需要更多的空间去存储。参考http://westpavilion.blogspot.com/2014/02/k-sum-problem.html的分析。
reference
http://cs.stackexchange.com/questions/2973/generalised-3sum-k-sum-problem
http://blog.csdn.net/linhuanmars/article/details/19711651
http://westpavilion.blogspot.com/2014/02/k-sum-problem.html