(一)前言
做过leetcode的人都知道, 里面有2sum, 3sum(closest), 4sum等问题, 这些也是面试里面经典的问题, 考察是否可以合理利用排序这个性质, 一步一步得到高效的算法. 经过总结, 本人认为这些问题都可以使用一个通用的K sum求和问题加以概括消化, 这里我们先直接给出K Sum的问题描写叙述和算法(递归解法), 然后将这个一般性的方法套用到详细的K, 比方leetcode中的2Sum, 3Sum, 4Sum问题.
还有求最接近target的2、3、4个数，是上述问题的变形，思路变化不大。
（二）leetcode求和问题描写叙述(K sum problem)：
K sum的求和问题通常是这样子描写叙述的：给你一组N个数字(比方 vector<int> num), 然后给你一个常数(比方 int target) ，我们的goal是在这一堆数里面找到K个数字。使得这K个数字的和等于target。
（三）注意事项
注意这一组数字可能有反复项：比方 1 1 2 3 , 求3sum, 然后 target = 6, 你搜的时候可能会得到 两组1 2 3, 1 2 3，1 来自第一个1或者第二个1, 可是结果事实上仅仅有一组，所以最后结果要去重。
去重的方法有两个：
（1）前后移动探測，发现反复数字
//寻找其它可能的2个数，顺带去重
while (++p < q && num[p-1] == num[p])
{
//do nothing
}
while (--q > p && num[q+1] == num[q])
{
//do noghing
} （2）借助STL容器 set：set<vector<int> >
set不同意有反复的值出现。
（四）K Sum求解方法, 适用leetcode 2Sum, 3Sum, 4Sum
方法一： 暴力，就是枚举全部的K-subset, 那么这种复杂度就是 从N选出K个，复杂度是O(N^K)
方法二： 排序+贪心
这个方案适用于2sum。3sum。 3sum cloest(找3个数的和最接近target),4sum ,4sum cloest（4个数的和最接近target）问题
整体思路：
2sum：先排序，默认非递减排序，固定0个数，头尾双指针选定2个数。利用贪心策略（sum-target>0,则尾指针左移，相反头指针右移，非常easy证明），直至找到sum=target
相似于二分查找，时间复杂度O（N）
3 sum：先排序。固定1个数（外层一个for循环遍历）。再採用头尾双指针选定两个数。仍然採用贪心策略移动指针，得到3sum =target
时间复杂度O（N*N）
3 sum cloest:原理同3sum。仅仅只是多了比較，以下有代码贴出，看一眼就明确，时间复杂度O（N*N）
4 sum：因为贪心策略仅仅适用于双指针，所以这里须要固定2个数。怎么固定？双层for循环遍历。！
！再引入头尾双指针，时间复杂度O（N*N*N）
4sum cloest：同上 ，时间复杂度O（N*N*N）
//2 sum
int i = starting; //头指针
int j = num.size() - 1; //尾指针
while(i < j) {
int sum = num[i] + num[j];
if(sum == target) {
store num[i] and num[j] somewhere;
if(we need only one such pair of numbers)
break;
otherwise
do ++i, --j;
}
else if(sum < target)
++i;
else
--j;
}//3 sum
//对原数组非递减（递增）排序
InsertSort(num,num.size());
for (int i = 0; i < num.size(); ++i)
{
//去重
if (i != 0 && num[i] == num[i-1])
continue;
int p = i + 1, q = num.size() - 1;
int sum = 0;
//收缩法寻找第2，第3个数
while (p < q)
{
sum = num[i] + num[p] + num[q];
if (sum == 0)
{
vector<int> newRes;
newRes.push_back(num[i]);
newRes.push_back(num[p]);
newRes.push_back(num[q]);
InsertSort(newRes,newRes.size());
res.push_back(newRes);
//寻找其它可能的2个数。顺带去重
while (++p < q && num[p-1] == num[p])
{
//do nothing
}
while (--q > p && num[q+1] == num[q])
{
//do noghing
}
}
else if (sum < 0) //和太小，p向后移动
{
++p;
}
else //和过大，q向前移动
{
--q;
}
}
}<span style="font-family: Arial, Helvetica, sans-serif;">// 3 sum cloest
class Solution {</span>public:
int threeSumClosest(vector<int> &num, int target) {
int index;
bool flag=true;
sort(num.begin(),num.end());
if(num.at(0)+num.at(1)+num.at(2)>target)
index=num.at(0)+num.at(1)+num.at(2)-target ;
else
{
index=target-(num.at(0)+num.at(1)+num.at(2));
flag=false;
}
for (int i = 0; i < num.size(); ++i)
{
int p = i + 1, q = num.size() - 1;
int sum=0;
while (p < q)
{
sum = num[i] + num[p] + num[q];
if (sum == target)
{
return sum;
}//if
else if (sum < target) //和太小，p向后移动
{
++p;
if(target-sum<index)
{
index=target-sum;
flag=false;
}
}
else //和过大。q向前移动
{
--q;
if(sum-target<index)
{
index=sum-target;
flag=true;
}
}//else
}//while
}//for
if(flag)
return index+target;
else
return target-index;
}
};
//4 sum
class Solution
{
public:
vector<vector<int> > fourSum(vector<int> &num, int target) {
// Note: The Solution object is instantiated only once.
vector<vector<int>> res;
int numlen = num.size();
if(num.size()<4)return res;
sort(num.begin(),num.end());
set<vector<int>> tmpres;
for(int i = 0; i < numlen; i++)
{
for(int j = i+1; j < numlen; j++)
{
int begin = j+1;
int end = numlen-1;
while(begin < end)
{
int sum = num[i]+ num[j] + num[begin] + num[end];
if(sum == target)
{
vector<int> tmp;
tmp.push_back(num[i]);
tmp.push_back(num[j]);
tmp.push_back(num[begin]);
tmp.push_back(num[end]);
tmpres.insert(tmp);
begin++;
end--;
}else if(sum<target)
begin++;
else
end--;
}
}
}
set<vector<int>>::iterator it = tmpres.begin();
for(; it != tmpres.end(); it++)
res.push_back(*it);
return res;
}
};