3Sum

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note:

• Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
• The solution set must not contain duplicate triplets.

    For example, given array S = {-1 0 1 2 -1 -4},    A solution set is:    (-1, 0, 1)    (-1, -1, 2)

/** 整理的提交代码 * 处理复杂度为O(n3)，不过其中获取符合条件三元组时对重复元素也进行了计算，最后又进行了排序来通一去重使得效率很低  * 主要思路： * 1、为了选出的三元组是非递减的，先对输入数组进行排序 * 2、穷举法选取符合条件的三元组，由于每个元素只能取一次，所以当前循环的起始为上次循环起始之后 * 3、由于原始输入数组本身可能包含重复元素，所以需要对选取到的三元组进行筛选移除重复三元组 * 提交结果： * (Judge Small) * Run Status: Accepted! * Program Runtime: 8 milli secs （基本稳定在几毫秒） * Progress: 28/28 test cases passed. * (Judge Large) * Run Status: Time Limit Exceeded （超时了！） */#include <vector>#include <algorithm>#include <functional>#include <iostream>//#include "LeetCode.h" // 原本下面的类放在该头文件中，但是VS2005编译一直编译出错，放到main文件中则可以，没搞懂。using namespace std;class Solution {public:vector<vector<int> > threeSum(vector<int> &num) {        // Start typing your C/C++ solution below        // DO NOT write int main() function        sort(num.begin(), num.end());        size_t size = num.size();                vector<int> triplet;        vector<vector<int> > result;        for (size_t i = 0; i < size; i++)        {            if(num[i] > 0)            {                break;            }            for (size_t j = i+1; j < size; j++)            {                for (size_t k = j+1; k < size; k++)                {                    if (num[i] + num[j] + num[k] == 0)                    {                        triplet.push_back(num[i]);                        triplet.push_back(num[j]);                        triplet.push_back(num[k]);                        result.push_back(triplet);                        triplet.clear();                    }                }            }        }                vector<vector<int> >::iterator end = result.end();sort(result.begin(), end, less<vector<int> >());        vector<vector<int> >::iterator new_end = unique(result.begin(), end);        result.erase(new_end, end);                return result;    }};int main(){vector<int> num;int number;while (cin >> number){num.push_back(number);}vector<vector<int> > result;Solution s;result = s.threeSum(num);for (size_t i = 0; i < result.size(); i++){for (size_t j = 0; j < 3; j++){cout << result[i][j] << ' ';}cout << endl;}return 0;}

/** 整理的提交代码 * 处理复杂度为O(n3)，这次是在获取符合条件的三元组时就进行了“实时”去重 * 主要思路： * 1、为了选出的三元组是非递减的，先对输入数组进行排序 * 2、穷举法选取符合条件的三元组，由于每个元素只能取一次，所以当前循环的起始为上次循环起始之后 * 3、由于原始输入数组本身可能包含重复元素，所以需要对选取到的三元组进行筛选移除重复三元组 * 提交结果： * (Judge Small) * Run Status: Accepted! * Program Runtime: 8 milli secs （基本稳定在几毫秒） * Progress: 28/28 test cases passed. * (Judge Large) * Run Status: Accepted! * Program Runtime: 280 milli secs （基本稳定在二百多毫秒） * Progress: 311/311 test cases passed. */#include <vector>#include <algorithm>#include <functional>#include <iostream>//#include "LeetCode.h" // 原本下面的类放在该头文件中，但是VS2005编译一直编译出错，放到main文件中则可以，没搞懂。using namespace std;class Solution {public:vector<vector<int> > threeSum(vector<int> &num) {        // Start typing your C/C++ solution below        // DO NOT write int main() function        sort(num.begin(), num.end());        size_t size = num.size();                vector<int> triplet;        vector<vector<int> > result;        for (size_t i = 0; i < size; i++)        {// 如果第一个考察的元素已经大于目标0，则直接返回            if(num[i] > 0)            {                break;            }// 首次去重，如果当前元素考察的第一个元素与上一次考察的第一个元素相同，则跳过这次// 必须先判断i>0，否则在i=0时内存违规访问runtime errorif (i > 0 && num[i] == num[i-1]){continue;}            for (size_t j = i+1; j < size; j++)            {// 去重，如果当前元素考察的第二个元素与上一次考察的第二个元素相同，则跳过这次// 限制的是符合条件的三元组中的第二个元素，这里需要判断j>i+1，以避免与第一个元素比较if (j > i+1 && num[j] == num[j-1]){continue;}                for (size_t k = j+1; k < size; k++)                {// 去重，原理与上同if (k > j+1 && num[k] == num[k-1]){continue;}// 这里的符合条件的三元组已经经过了所有的去重处理，是最终结果中的一个                    if (num[i] + num[j] + num[k] == 0)                    {                        triplet.push_back(num[i]);                        triplet.push_back(num[j]);                        triplet.push_back(num[k]);                        result.push_back(triplet);                        triplet.clear();                    }                }            }        }        //      vector<vector<int> >::iterator end = result.end();//sort(result.begin(), end, less<vector<int> >());//      vector<vector<int> >::iterator new_end = unique(result.begin(), end);//      result.erase(new_end, end);                return result;    }};

/** 整理的提交代码 * 主要思路： * 处理复杂度为O(n2)，不过其中获取符合条件三元组时对重复元素也进行了计算，最后又进行了排序来同一去重使得效率很低 * 1、为了选出的三元组是非递减的，先对输入数组进行排序 * 2、枚举法选取符合条件的三元组，由于每个元素只能取一次，所以当前循环的起始为上次循环起始之后 * 3、由于原始输入数组本身可能包含重复元素，所以需要对选取到的三元组进行筛选移除重复三元组 * 提交结果： * (Judge Small) * Run Status: Accepted! * Program Runtime: 12 milli secs （基本在几毫秒） * Progress: 28/28 test cases passed. * (Judge Large) * Run Status: Accepted! * Program Runtime: 1024 milli secs （基本稳定在一点几毫秒） * Progress: 311/311 test cases passed. */#include <vector>#include <algorithm>#include <functional>#include <iostream>using namespace std;class Solution {public:vector<vector<int> > threeSum(vector<int> &num) {        // Start typing your C/C++ solution below// DO NOT write int main() functionvector<int> triplet;vector<vector<int> > result;        sort(num.begin(), num.end());        size_t size = num.size();if (size < 3){return result;}        size_t i, j, k;int sum;// num[i]<num[j]<num[k] 分别为三元组的三个元素，先取得二元组然后寻找另外一个for (i = 0; i < size-2; i++){if (num[i] > 0){break;}j = i+1;k = size - 1;while (j < k){sum = num[i] + num[j] + num[k];if (sum == 0){triplet.push_back(num[i]);// 三元组第一个元素triplet.push_back(num[j]);// 三元组第二个元素triplet.push_back(num[k]);// 三元组第三个元素result.push_back(triplet);triplet.clear();j++;}else if (sum > 0)// {k = k - 1;}else{j = j + 1;}}}        vector<vector<int> >::iterator end = result.end();sort(result.begin(), result.end(), less<vector<int> >());// 此处需要重新排序，比较元素为vector        vector<vector<int> >::iterator new_end = unique(result.begin(), end);        result.erase(new_end, end);                return result;    }};

/** 整理的提交代码 * 主要思路： * 处理复杂度为O(n2)，这次是在获取符合条件的三元组时就进行了“实时”去重 * 1、为了选出的三元组是非递减的，先对输入数组进行排序 * 2、符合条件的三元组的第一个元素选取范围为[0...n-3]， *    第二个元素和第三个元素的获取就如求“一个数组中的两个数的和等于某一目标值”，从第一个元素之后开始考察 *     如果找到符合条件的三元组则第二个向前移动，否则根据与目标值的关系来向前移动第二个元素（<目标值）或者 *     向后移动第三个元素（>目标值） * 3、由于原始输入数组本身可能包含重复元素，所以需要对选取到的三元组进行筛选移除重复三元组 * 提交结果： * (Judge Small) * Run Status: Accepted! * Program Runtime: 8 milli secs （基本在几毫秒） * Progress: 28/28 test cases passed. * (Judge Large) * Run Status: Accepted! * Program Runtime: 248 milli secs （基本稳定在二百五十毫秒左右） * Progress: 311/311 test cases passed. */#include <vector>#include <algorithm>#include <functional>#include <iostream>using namespace std;class Solution {public:vector<vector<int> > threeSum(vector<int> &num) {        // Start typing your C/C++ solution below// DO NOT write int main() functionvector<int> triplet;vector<vector<int> > result;        sort(num.begin(), num.end());        size_t size = num.size();if (size < 3){return result;}        size_t i, j, k;int sum;// (i<j<k && num[i]<=num[j]<=num[k]) 分别为三元组的三个元素，先取得二元组然后寻找另外一个for (i = 0; i < size-2; i++){// 如果第一个考察的元素已经大于目标0，则直接返回if (num[i] > 0){break;}// 首次去重，如果当前元素考察的第一个元素与上一次考察的第一个元素相同，则跳过这次// 必须先判断i>0，否则在i=0时内存违规访问runtime errorif (i > 0 && num[i] == num[i-1]){continue;}// 第二个考察元素小于等于第一个考察元素，从当前考察的第一个元素之后开始考察j = i+1; // 第三个考察元素则是从数组末尾开始进行考察k = size - 1;while (j < k){sum = num[i] + num[j] + num[k];if (sum == 0){// 如果当前元素考察的第二个元素与上一次考察的第二个元素相同，则跳过这次// 限制的是符合条件的三元组中的第二个元素，这里需要判断j>i+1，以避免与第一个元素比较if (num[j] == num[j-1] && j > i+1){j = j + 1;continue;}triplet.push_back(num[i]);// 三元组第一个元素triplet.push_back(num[j]);// 三元组第二个元素triplet.push_back(num[k]);// 三元组第三个元素result.push_back(triplet);triplet.clear();j++;// 第二个考察元素移动}else if (sum > 0)// {k = k - 1;// 避免重复计算，当前考察的三元组第三个元素与上一次考察的相等则跳过这个元素，// 其实这时只是避免考察它，因为如果当前考察元素与上个考察元素相同，// 下次的求和结果还是大于0。// 所以其实它不会出现在结果中，只是为了避免下次重复计算和以及判断// 可以不用判断，只是影响了一点效率，结果正确if (num[k] == num[k+1]){k = k - 1;}}else{j = j + 1;// 避免重复计算，这里的考虑与上面k的考虑原理相同// 可以不用判断，只是影响了一点效率，结果正确if (num[j] == num[j-1]){j = j + 1;}}}}//      vector<vector<int> >::iterator end = result.end();//sort(result.begin(), result.end(), less<vector<int> >());// 此处需要重新排序，比较元素为vector//      vector<vector<int> >::iterator new_end = unique(result.begin(), end);//      result.erase(new_end, end);                return result;    }};

参考：http://en.wikipedia.org/wiki/3SUM

Assume we have as input array S with elements S[0]..S[n-1]. Then the following algorithm will solve 3SUM problem in quadratic time.^[1]

 sort(S); for i=0 to n-3 do    a = S[i];    k = i+1;    l = n-1;    while (k<l) do       b = S[k];       c = S[l];       if (a+b+c == 0) then          output a, b, c;          exit;       else if (a+b+c > 0) then          l = l - 1;       else          k = k + 1;       end       end end

另外可参考：http://blog.csdn.net/wyc1230/article/details/7368407 ，这里使用map来记录找到的记过，找的过程中在里面查找来去重。其中map的key选用的是一个对符合条件的三元组经过哈希的值，通过mymap[哈希值]=1；来向map插入找到的符合条件的三元组的哈希值和1组成的pair。由于这里的value其实没用，所以可以用set来替换map进行去重（这里用的查找是该容器的成员函数而不要使用算法中的sort函数，这样可以利用已排序的性质，成员函数实现时使用的是二分查找法，效率高）。这种去重方法在一定程度上会影响效率，因为它另外使用了map或者set来记录已找到的三元组，其中有插入，查找等过程都是要消耗时间的，同时这些数据结构也占用了部分内存。