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 error
if (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() function
vector<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() function
vector<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 error
if (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来记录已找到的三元组，其中有插入，查找等过程都是要消耗时间的，同时这些数据结构也占用了部分内存。
899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
