LeetCode15-三数之和

LeetCode15-三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：

[
  [-1, 0, 1],
  [-1, -1, 2]
]

一、思路

（一）直觉想法

1、三重循环

双重循环行不通，其实从组合数量出发，因为组合个数是$n^3$这个数量级，要遍历所有的组合，时间复杂度应该也在$O(n^3)$的样子，使用三重循环应该是最佳的方法：

（1）第一重循环：left（取值范围：$0-n-3$）
（2）第二重循环：middle（取值范围：$1-n-2$）
（3）第三重循环：right（取值范围：$2-n-1$）

2、排序之后

等等，之前的结论都是建立在数组是无序的情况下，事实上，对数组排序的时间复杂度也仅仅是$O(nlogn)$，如果使用排序后的数组能否大幅减少查找时间呢？

每次将三个数之和（$sum=left+middle+right$）与0比较：
（1）比0大则移动middle或者left
（2）比0小则移动middle或者right
（3）等于0，则保存下来，然后？？？

这个方法也有很多问题，每次的移动，有两个选择，但是这两个选择并不是等价的
比如说当：
$sum>0$时，移动middle好呢还是移动right好？
还有当出现0的时候，为了寻找下一个零，该怎么移动？

3、分而治之

联想之前两数之和，三数之和的问题能否转为两数之和呢？
答案是肯定的。假设三个数为：i，j，k。对于两数之和的target，这里要求：target=-i
然后遍历整个数组，时间复杂度应该是：$O(n^2)$

（二）分而治之

最终我采用了这个方案，但是还是有些问题：
（1）因为数组中可能存在重复的数，此时会有两个一样的target，返回的vector也是一样的
（2）多对多的问题：
例如：i+j+k=0
对i来说，还有：
i+j1+k1=0
i+j2+k2=0
…
i+jn+kn=0

对j来说，还有：
i1+j+k1=0
i2+j+k2=0
…
in+j+kn=0

同理，k也有这种可能
但是之前的两数之和的程序是假定，只有一个解

1、尝试-集合去重

接下来给出解决上述问题的方案：
（1）使用set来保存数组中的数，这样可以达到去重的目的
（2）使用set来保存得到的向量，且必须保持向量中的相对位置不变，这样也可以去除重复的向量

很遗憾，这个想法是错误的，比如：[-1,0,1,-1]
第一次将[-1,0,1]放入集合，第二次还是会将[0,1,-1]也放进集合里面

再比如：[-1,0,1,-1,0]这样的数据
第一次将-1所在的所有向量选出来时，就已经重复了：
[-1,0,1]
[-1,1,0]
因此，集合没有办法对向量去重

实际上去重失败的原因是：无法通过相对位置来决定唯一向量。所以，只要事先进行排序，就能解决这个问题：

C++代码：

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		vector<vector<int>> nums_vector;
		// 保存三数之和为0的向量
		vector<int> nums1;
		// 除去重复nums中的重复整数
		set<int> nums_p1;
		// 除去nums_vector中的重复向量
		set<vector<int>> nums_pp;
		map<int, int> hashmap;
	
		int i, complement, k, target, n, j;

		if (nums.size() < 3)
			return nums_vector;
		sort(nums.begin(), nums.end());

		for (n = 0; n < nums.size(); n++) {
			if (nums_p1.count(nums[n]) == 0) {
				nums_p1.insert(nums[n]);
				target = -nums[n];
				// 寻找两数之和
				for (i = n + 1; i < nums.size(); i++) {
					complement = target - nums[i];
					hashmap.insert(map<int, int>::value_type(nums[i], complement));
					if (hashmap.count(complement) != 0) {
						for (j = n + 1; j < i; j++) {
							// 由于哈希表建立时，是从前开始的，因此j<i
							if (nums[j] == complement) {
								nums1.push_back(nums[n]);
								nums1.push_back(nums[j]);
								nums1.push_back(nums[i]);
								nums_pp.insert(nums1);
								break;
							}
						}
						// 清空向量，继续找下一个
						nums1.clear();
					}
				}
				// 清空哈希表
				hashmap.clear();
			}
		}
		for (set<vector<int>>::iterator it = nums_pp.begin(); it != nums_pp.end(); it++)
			nums_vector.push_back(*it);
		return nums_vector;
	}
};

执行效率：

港真，我都不想上图了
更让我震惊的是使用内存

？？？？？？？？？？？？？？？？？？？？？？？？？？？？
短短50行的代码用了600多MB的内存，这是咋回事？？？？？？？

更新：
这么慢应该不是哈希表的问题，我觉得是因为不必要的操作太多了，而且使用这种方法找两数之和，不如双指针来的快，实际上这个代码已经是显式的三重循环了

（三）分而治之：双指针

主要的思想还是分而治之，但是在解决两数之和的问题时，不采用哈希表，使用双指针，看看速度能否更快一点

C++代码：

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		vector<vector<int>> nums_vector;
		// 保存三数之和为0的向量
		vector<int> nums1;
		set<int> nums_p1;
		int i, j, k = 0, n;

		if (nums.size() < 3)
			return nums_vector;
		sort(nums.begin(), nums.end());

		for (n = 0; n < nums.size(); n++) {
			if (nums_p1.count(nums[n]) == 0) {
				nums_p1.insert(nums[n]);
				i = n + 1;
				j = nums.size() - 1;
				while (i < j) {
					if (nums[n] + nums[i] + nums[j] > 0) {
						j--;
						continue;
					}	
					if (nums[n] + nums[i] + nums[j] < 0) {
						i++;
						continue;
					}
					if (nums[n] + nums[i] + nums[j] == 0) {
						nums1.push_back(nums[n]);
						nums1.push_back(nums[i]);
						nums1.push_back(nums[j]);
						nums_vector.push_back(nums1);
						nums1.clear();
						while (i + 1 < j && nums[i] == nums[i + 1])
							i++;
						while (j - 1 > i && nums[j] == nums[j - 1])
							j--;
						i++;
					}
				}
			}
		}
		return nums_vector;
	}
};

执行效率：

比之前的版本强了很多，但是还是比较慢
内存占用：

可见，还是占了很大一部分的内存

仔细看看这段代码，会发现很多地方写的很冗余
（1）冗余1

if (nums_p1.count(nums[n]) == 0) 
修改为：
if (n > 0 && nums[n] == nums[n - 1])

使用set判定重复，实际由于已经排好序了，因此判定重复只用与前一个元素比较即可

（2）冗余2
对向量的重复操作，总是在不断插入删除

C++代码：

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		// 保存三数之和为0的向量
		vector<int> nums1;
		set<vector<int>> nums_vector;
		int i, j, k = 0, target, n;

		if (nums.size() < 3)
			return vector<vector<int>>(nums_vector.begin(), nums_vector.end());
		sort(nums.begin(), nums.end());

		for (n = 0; n < nums.size(); n++) {
			if (nums[n] > 0)
				break;

			if (n > 0 && nums[n] == nums[n - 1])
				continue;

			i = n + 1;
			j = nums.size() - 1;
			target = -nums[n];
			while (i < j) {
				if (nums[i] + nums[j] > target) {
					j--;
					continue;
				}
				if (nums[i] + nums[j] < target) {
					i++;
					continue;
				}
				if ( nums[i] + nums[j] == target) {
					nums_vector.insert({ nums[n],nums[i],nums[j] });
					while (i + 1 < j && nums[i] == nums[i + 1])
						i++;
					while (j - 1 > i && nums[j] == nums[j - 1])
						j--;
					i++;
				}
			}
		}
		return vector<vector<int>>(nums_vector.begin(), nums_vector.end());
	}
};

效率还是老样子，没什么提升。。。。。。。
看了排名靠前的几个，思路差不多，不知道为啥那么快