标签：style blog http color 使用 strong
本文载自【k sum problem 】以及【NSum】有位同僚，对该问题做出了代码的小结，想看吗？戳我戳我。
问题陈述：
在一个数组，从中找出k个数（每个数不能重复取。数组中同一个值有多个，可以取多个），使得和为零。找出所有这样的组合，要求没有重复项（只要值不同即可，不要求在原数组中的index不同）
解法：
2 sum 用hash table做，可以时间O(n)，空间O（n），
2 sum 如果用sort以后，在前后扫描，可以时间O(nlogn + n) = O(nlogn)，空间O(1)
2 sum 用hash table做的好处是快，但是等于是利用了不用排序的特点。排序的办法，在高维度（也就是k sum问题，k>2）的时候，nlogn就不是主要的时间消耗成分，也就更适合2sum的sort后双指针扫描查找的办法。
那么，对于k sum， k>2的，如果用sort的话， 可以 对 n-2的数做嵌套循环，因为已经sort过了，最后剩下的两维用2 sum的第二个办法， 时间是O(nlogn + n^(k-2) * n) = O(n^(n-1))，空间O(1)。 但是这样跟纯嵌套循环没有什么区别，只是最后一层少了一个因子n。有什么办法能优化？
就是说，对于 k sum (k>2) 问题 （一个size为n的array, 查找k个数的一个tuple，满足总和sum为0）， 有没有时间复杂度在O(n^(k-2))的办法？
之前常规的一层一层剥离，n的次数是递增的。只有在最后一层，还有两个维度的时候，时间开销上减少一个n的因子，但是这样时间开销还是太多
我们可以通过对问题分解来解决
举个例子
...-5，-4，-3，-2，-1, 0，1, 2, 3, 4, 5.... 要找 4 sum = 0
那么先分解
4 分成 2 sum + 2 sum 来解决，但是这里的子问题2 sum没有sum=0的要求，是保留任何中间值。只有当子问题的2 sum解决以后，回归原问题的时候，我们才又回归原始的2 sum问题，这时候sum=0
子问题，空间和时间消耗，都是O(n^2)
回归大问题，时间消耗，是O(n^2)
假设k sum中 k = 2^m, 那么一共有m层，会有m次分解
分解到最底层，时间空间消耗 从 原始O(n)变为新的O(n^2)
分解到次底层，时间空间消耗 从 O(n^2)变为新的O((n^2)^2)
...
到达最顶层，时间空间消耗就都变成了O(n^(2*m)) = O(n^(2logk))
和之前的方法O(n^(k-1))相比，O(n^(2logk))的时间是少了很多，但是空间消耗却很大。
因为子问题无法确定把哪一个中间结果留下，那么就需要把子问题的结果全部返回，到最后，空间消耗就很大了。整体效果算是空间换时间吧。
通过 问题的分解 + hashtable的运用，能明显减少时间消耗， 但是空间消耗变大是个问题。比如说，如果有10^6的int类型数组，我如果用这个hashtable的办法，就要有10^12的pair，这就有10T以上的空间消耗。
问题的分解是个很好的思路，但是中间值得保留迫使空间消耗增大，这和用不用hashtable倒没有很大关系，只是说，如果不用hashtable，时间消耗会更大。
另外，还有一些题目的变形，比如如果要求所有组合，满足
sum < k,
sum = k,
sum > k,
或者是 closest to k
遇到这些变形的时候，hashtable的做法就显得乏力了，但是嵌套循环的方式却仍是可行的。尤其是对closest to k这种非确定性的要求。
【NSum】小结:
做过leetcode的人都知道, 里面有2sum, 3sum(closest), 4sum等问题, 这些也是面试里面经典的问题, 考察是否能够合理利用排序这个性质, 一步一步得到高效的算法. 经过总结, 本人觉得这些问题都可以使用一个通用的K sum求和问题加以概括消化, 这里我们先直接给出K Sum的问题描述和算法(递归解法), 然后将这个一般性的方法套用到具体的K, 比如leetcode中的2Sum, 3Sum, 4Sum问题. 同时我们也给出另一种哈希算法的讨论.
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, 但是结果其实只有一组，所以最后结果要去重。
方法一： 暴力，就是枚举所有的K-subset, 那么这样的复杂度就是 从N选出K个，复杂度是O(N^K)
方法二： 排序，这个算法可以考虑最简单的case, 2sum，这是个经典问题，方法就是先排序，然后利用头尾指针找到两个数使得他们的和等于target, 这个2sum算法网上一搜就有，这里不赘述了，给出2sum的核心代码：
1 //2 sum 2 int i = starting; //头指针 3 int j = num.size() - 1; //尾指针 4 while(i < j) { 5 int sum = num[i] + num[j]; 6 if(sum == target) { 7 store num[i] and num[j] somewhere; 8 if(we need only one such pair of numbers) 9 break; 10 otherwise 11 do ++i, --j; 12 } 13 else if(sum < target) 14 ++i; 15 else 16 --j; 17 }
2sum的算法复杂度是O(N log N) 因为排序用了N log N以及头尾指针的搜索是线性的，所以总体是O(N log N)，好了现在考虑3sum, 有了2sum其实3sum就不难了，这样想：先取出一个数，那么我只要在剩下的数字里面找到两个数字使得他们的和等于(target – 那个取出的数)就可以了吧。所以3sum就退化成了2sum, 取出一个数字，这样的数字有N个，所以3sum的算法复杂度就是O(N^2 ), 注意这里复杂度是N平方，因为你排序只需要排一次，后面的工作都是取出一个数字，然后找剩下的两个数字，找两个数字是2sum用头尾指针线性扫，这里很容易错误的将复杂度算成O(N^2 log N)，这个是不对的。我们继续的话4sum也就可以退化成3sum问题(copyright @sigmainfy)，那么以此类推，K-sum一步一步退化，最后也就是解决一个2sum的问题，K sum的复杂度是O(n^(K-1))。 这个界好像是最好的界了，也就是K-sum问题最好也就能做到O(n^(K-1))复杂度，之前有看到过有人说可以严格数学证明，这里就不深入研究了。
更新: 感谢网友Hatch提供他的K Sum源代码, 经供参考:
1 class Solution { 2 public: 3 vector< vector > findZeroSumInSortedArr(vector &num, int begin, int count, int target) 4 { 5 vector<vector > ret; 6 vector tuple; 7 set visited; 8 if (count == 2) 9 { 10 int i = begin, j = num.size()-1; 11 while (i < j) 12 { 13 int sum = num[i] + num[j]; 14 if (sum == target && visited.find(num[i]) == visited.end()) 15 { 16 tuple.clear(); 17 visited.insert(num[i]); 18 visited.insert(num[j]); 19 tuple.push_back(num[i]); 20 tuple.push_back(num[j]); 21 ret.push_back(tuple); 22 i++; j–; 23 } 24 else if (sum < target) 25 { 26 i++; 27 } 28 else 29 { 30 j–; 31 } 32 } 33 } 34 else 35 { 36 for (int i=begin; i<num.size(); i++) 37 { 38 if (visited.find(num[i]) == visited.end()) 39 { 40 visited.insert(num[i]); 41 vector subRet = findZeroSumInSortedArr(num, i+1, count-1, target-num[i]); 42 if (!subRet.empty()) 43 { 44 for (int j=0; j<subRet.size(); j++) 45 { 46 subRet[j].insert(subRet[j].begin(), num[i]); 47 } 48 49 ret.insert(ret.end(), subRet.begin(), subRet.end()); 50 } 51 } 52 } 53 } 54 55 return ret; 56 } 57 58 vector threeSum(vector &num) { 59 sort(num.begin(), num.end()); 60 return findZeroSumInSortedArr(num, 0, 3, 0); 61 } 62 63 vector fourSum(vector &num, int target) { 64 sort(num.begin(), num.end()); 65 return findZeroSumInSortedArr(num, 0, 4, target); 66 } 67 };
这里讲两点，第一，注意比如3sum的时候，先整体排一次序，然后枚举第三个数字的时候不需要重复， 比如排好序以后的数字是 a b c d e f, 那么第一次枚举a, 在剩下的b c d e f中进行2 sum, 完了以后第二次枚举b, 只需要在 c d e f中进行2sum好了，而不是在a c d e f中进行2sum, 这个大家可以自己体会一下，想通了还是挺有帮助的。第二，K Sum可以写一个递归程序很优雅的解决，具体大家可以自己试一试。写递归的时候注意不要重复排序就行了。
因为已经收到好几个网友的邮件需要3sum的源代码, 那么还是贴一下吧, 下面的代码是可以通过leetcode OJ的代码(又重新写了一遍, 于Jan, 11, 2014 Accepted), 就当是K sum的完整的一个case study吧, 顺便解释一下上面的排序这个注意点, 同时我也有关于结果去重的问题可以和大家讨论一下, 也请大家集思广益, 发表意见, 首先看源代码如下：
1 class Solution { 2 public: 3 vector threeSum(vector &num) { 4 vector vecResult; 5 if(num.size() < 3) 6 return vecResult; 7 8 vector vecTriple(3, 0); 9 sort(num.begin(), num.end()); 10 int iCurrentValue = num[0]; 11 int iCount = num.size() - 2; // (1) trick 1 12 for(int i = 0; i < iCount; ++i) { 13 if(i && num[i] == iCurrentValue) { // (2) trick 2: trying to avoid repeating triples 14 continue; 15 } 16 // do 2 sum 17 vecTriple[0] = num[i]; 18 int j = i + 1; 19 int k = num.size() - 1; 20 while(j < k) { 21 int iSum = num[j] + num[k]; 22 if(iSum + vecTriple[0] == 0) { 23 vecTriple[1] = num[j]; 24 vecTriple[2] = num[k]; 25 vecResult.push_back(vecTriple); // copy constructor 26 ++j; 27 --k; 28 } 29 else if(iSum + vecTriple[0] < 0) 30 ++j; 31 else 32 --k; 33 } 34 iCurrentValue = num[i]; 35 } 36 // trick 3: indeed remove all repeated triplets 37 // trick 4: already sorted, no need to sort the triplets at all, think about why? 38 vector< vector >::iterator it = unique(vecResult.begin(), vecResult.end()); 39 vecResult.resize( distance(vecResult.begin(), it) ); 40 return vecResult; 41 } 42 };
首先呢, 在K Sum问题中都有个结果去重的问题, 前文也说了, 如果输入中就有重复元素的话, 最后结果都需要去重, 去重有好几个办法, 可以利用std::set的性质(如leetcode上3sum的文章, 但是他那个文章的问题是, set没用好, 导致最终复杂度其实是O(N^2 * log N), 而非真正的O(N^2) ), 可以利用排序(如本文的方法)等, 去重本身不难(copyright @sigmainfy), 难的是不利用任何排序或者std::set直接得到没有重复的triplet结果集. 本人试图通过已经排好序这个性质来做到这一点(试图不用trick 3和4下面的两条语句), 但是经过验证这样的代码(没有trick 3, 4下面的两行代码, 直接return vecResult)也不能保证结果没有重复，于是不得不加上了trick 3, 4，还是需要通过在结果集上进一步去重. 笔者对于这个问题一直没有很好的想法, 希望这里的代码能抛砖引玉, 大家也讨论一下有没有办法, 或者利用排序的性质或者利用其它方法, 直接得到没有重复元素的triplet结果集, 不需要去重这个步骤.
那么还是解释一下源代码里面有四个trick, 以及笔者试图不利用任何std::set或者排序而做到去重的想法. 第一个无关紧要顺带的小trick 1, 是说我们排好序以后, 只需要检测到倒数第三个数字就行了, 因为剩下的只有一种triplet 由最后三个数字组成. 接下来三个trick都是和排序以及最后结果的去重问题有关的, 我一起说.
笔者为了达到不需要在最后的结果集做额外的去重, 尝试了以下努力: 首先对输入数组整体排序, 然后使用之前提到的3sum的算法, 每次按照顺序先定下triplet的第一个数字, 然后在数组后面寻找2sum, 由于已经排好序, 为了防止重复, 我们要保证triplet的第一个数字没有重复, 举个例子, -3, – 3, 2, 1, 那么第二个-3不应该再被选为我们的第一个数字了, 因为在第一个-3定下来寻找2 sum的时候, 我们一定已经找到了所有以-3为第一个数字的triplet(trick 2). 但是这样做尽管可以避免一部分的重复, 但是还有另一种重复无法避免: -3, -3, -3, 6, 那么在定下第一个-3的时候, 我们已经有两组重复triplet <-3, -3, 6>， 如何在不使用std::set的情况下避免这类重复, 笔者至今没有很好的想法. 大家有和建议? 望不吝赐教！
更新: 感谢网友stayshan的留言提醒, 根据他的留言, 不用在最后再去重. 于是可以把trick 3, 4下面的两行代码去掉, 然后把while里面的copy constructor这条语句加上是否和前一个元素重复的判断变成下面的代码就行了.
这样的做法当然比我上面的代码更加优雅, 虽然本质其实是一样的, 只不过去重的阶段变化了, 进一步的, 我想探讨的是, 我们能不能通过”不产生任何重复的triplet”的方法直接得到没有重复的triplet集合? 网友stayshan提到的方法其实还是可能生成重复的triplet, 然后通过和已有的triplet集合判断去重,笔者在这里试图所做的尝试更加确切的讲是想找到一种方法, 可以保证不生成重复的triplet. 现有的方法似乎都是post-processing, i.e., 生成了重复的triplet以后进行去重. 笔者想在这里探讨从而找到一种我觉得可以叫他pre-processing的方法, 能够通过一定的性质(可能是排序的性质等)保证不会生成triplet, 从而达到不需任何去重的后处理(post-processing)手段. 感觉笔者抛出的砖已经引出了挺好的思路了啊, 太好了, 大家有啥更好的建议, 还请指教啊 ：）
1 class Solution { 2 public: 3 vector threeSum(vector &num) { 4 // same as above 5 // ... 6 for(int i = 0; i < iCount; ++i) { 7 // same as above 8 // ... 9 while(j < k) { 10 int iSum = num[j] + num[k]; 11 if(iSum + vecTriple[0] == 0) { 12 vecTriple[1] = num[j]; 13 vecTriple[2] = num[k]; 14 if(vecResult.size() == 0 || vecTriple != vecResult[vecResult.size() - 1]) 15 vecResult.push_back(vecTriple); // copy constructor 16 ++j; 17 --k; 18 } 19 else if(iSum + vecTriple[0] < 0) 20 ++j; 21 else 22 --k; 23 } 24 iCurrentValue = num[i]; 25 } 26 return vecResult; 27 } 28 };
其实比如2sum还是有线性解法的，就是用hashmap, 这样你check某个值存在不存在就是常数时间，那么给定一个sum, 只要线性扫描, 对每一个number判断sum – num存在不存在就可以了。注意这个算法对(copyright @sigmainfy)有重复元素的序列也是适用的。比如 2 3 3 4 那么hashtable可以使 hash(2) = 1; hash(3) = 1, hash(4) =1其他都是0, 那么check的时候，扫到两次3都是check sum – 3在不在hashtable中，注意最后返回所有符合的pair的时候也还是要去重。这样子推广的话 3sum 其实也有O(N^2)的类似hash算法，这点和之前是没有提高的，但是4sum就会有更快的一个算法。
O(N^2)把所有pair存入hash表，并且每个hash值下面可以跟一个list做成map， map[hashvalue] = list，每个list中的元素就是一个pair, 这个pair的和就是这个hash值，那么接下来求4sum就变成了在所有的pair value中求 2sum，这个就成了线性算法了，注意这里的线性又是针对pair数量(N^2)的线性，所以整体上这个算法是O(N^2)，而且因为我们挂了list, 所以只要符合4sum的我们都可以找到对应的是哪四个数字。
到这里为止有人提出这个算法不对 (感谢Jun提出这点!! See the comment below), 因为这里的算法似乎无法检查取出来的四个数字是否有重复的, 也就是说在转换成2sum问题得到的那些个pair中, 有可能会有重复元素, 比如说原来数组中的第一个元素其实是重复了两次才使得4 sum满足要求, 那么这样得到的四元组(四个数字的和等于给定的值), 其实只有三个原数组元素, 其中第一个元素用了两次, 那么这样就不对了. 如果仅从我上面的描述来看, 确实是没有办法检查重复的, 但是仔细想想我们只要在map中存pair的的时候记录下的不是原数组对应的值, 而是原数组的id,就可以避免这个问题了. 更加具体的, map[hashvalue] = list, 每个list的元素就是一个pair, 这个pair<int, int> 中的pair是原来的array id, 使得这两个id对应到元素组中的元素值的和就是这个hash值. 那么问题就没有了, 我们在转换成的2sum寻找所有pair value的2sum的同时要检查最后得到的四元组<id1, id2, id3, id4>没有重复id. 这样问题就解决了.
更新: 关于4Sum的Hash解法, 感谢网友Tenos和hahaer的评论, 笔者再三思考, 思来想去>_<对于hahaer提出的所有元素都是0, 而且Target也是0的这个case, 我想问题可能在这里.
首先如果要找出所有唯一的四元组(id1, id2, id3, id4)也就是id级别的四元组, 那么时间复杂度只能是O(N^4). 推理如下: 如果要找到所有的唯一的四元组(id1, id2, id3, id4)的话, 是一定要O(N^4)时间的, 因为在这个case里面, 就是一个组合问题, 在N个id里面任意取出4个不同的id, 都是符合我们条件的四元组, 光是这样, 答案就有 O(N^4)个, N个里面取四个的组合种数.
可是! 如果大家再去看看leetcode的题目的话, 其实题目要求是返回元素组成的四元组(而不是要求id组成的四元组唯一), 也就是元素级别的四元组(参考网友Jun和AmazingCaddy和我在评论中的讨论)在这个case中, 返回(0, 0, 0, 0)就好了, 而不是返回(id1， id2, id3, id4)也就是不用去管id的问题. 如果是这样的话我们就不需要比较id了, 利用set之类的post-processing的方法是可以得到唯一的(0, 0, 0, 0)的.
还是抛砖引玉吧, 如果大家在这个问题上还有什么想法, 还请留言指点
这篇文章主要想从一般的K sum问题的角度总结那些比较经典的求和问题比如leetcode里面的2sum, 3sum(closest), 4sum等问题, 文章先直接给出K Sum的问题描述和算法(递归解法), 然后将这个一般性的方法套用到具体的K, 比如leetcode中的2Sum, 3Sum, 4Sum问题. 同时我们也给出另一种哈希算法的讨论. 那么这篇文章基本上还是自己想到什么写什么，有疏忽不对的地方请大家指正，也欢迎留言讨论，如果需要源代码，请留言或者发邮件到info@tech-wonderland.net
以上内容载自，感谢原作者的分享
http://tech-wonderland.net/blog/summary-of-ksum-problems.html
http://westpavilion.blogspot.com/2014/02/k-sum-problem.html
http://www.cnblogs.com/TenosDoIt/p/3649607.html
标签：style blog http color 使用 strong
原文地址：http://www.cnblogs.com/huntfor/p/3841902.html
