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来记录已找到的三元组,其中有插入,查找等过程都是要消耗时间的,同时这些数据结构也占用了部分内存。