每天一道LeetCode-----给定序列中2/3/4个元素的和为target的所有集合，或3个元素的和最接近target的集合

原题链接

2Sum

Two Sum

意思是给定一个数组，求数组中哪两个元素的和是给定值。

蛮力法的求解就是两层for循环，时间复杂度是O(n2)。

class Solution {
public:vector<int> twoSum(vector<int>& nums, int target) {for(int i = 0; i < nums.size() - 1; ++i){for(int j = 0; j < nums.size(); ++j){if(i == j) continue;if(nums[i] + nums[j] == target)return {nums[i], nums[j]};}}}
};

显然这种方式对于算法题来说复杂度过高了，仔细想一下，每次固定一个i，变化j的时候，小于i的那部分其实在之前已经访问过一次了，为什么呢
假设nums.大小为10，此时i为5，j从0到9计算nums[i] + nums[j]

nums[0] + nums[5],
nums[1] + nums[5],
...
nums[4] + nums[5],

当i = 0, 1, 2, 3, 4时是不是都计算过？，所以又重复计算了一遍，整个程序多计算了n遍，这便是复杂度的原因。

解决方法，首先想到的优化就是让j从i+1开始

class Solution {
public:vector<int> twoSum(vector<int>& nums, int target) {for(int i = 0; i < nums.size() - 1; ++i){for(int j = i+1; j < nums.size(); ++j){if(nums[i] + nums[j] == target)return {nums[i], nums[j]};}}}
};

效率得到了一定优化，在考虑是否可以继续优化呢，想一下，在遍历j时

/* i == 5时遍历了 */
nums[6], nums[7], nums[8], nums[9];/* i == 6时遍历了 */
nums[7], nums[8] ...

所以发现对于i后面的那些仍然会重复遍历n次，还有什么方法可以优化呢，其实到这，再优化的方法只能想办法让复杂度变为O(n)，也就是让每一个元素只遍历一遍，那么就不能套循环，只能使用一层循环。

for(int i = 0; i < nums.size(); ++i)
{}

当遍历某个nums[i]时，唯一可能知道的、程序可能会优化的就是从nums[0]到nums[i-1]，因为nums[i]往后的元素还没有遍历过，根本不知道是什么。再想，可不可以不判断nums[i] + nums[j]的和而是直接判断i前面有没有nums[j]这个数呢？nums[j]是多少？（假设j是0到i-1中的某个数）

int left = target - nums[i];

我们只需要判断前i-1个数中有没有left就行了，那么就需要使用某种数据结构存储访问过的nums[i]，什么数据结构可以达到o(1)的效果呢？哈希表

/* 通常使用unordered_map来代表哈希表 */
class Solution {
public:vector<int> twoSum(vector<int>& nums, int target) {unordered_map<int, int> hash;for(int i = 0; i < nums.size(); ++i){int left = target - nums[i];if(hash.find(left) != hash.end())return {hash[left], i};elsehash[nums[i]] = i;}return {0, 0};}
};

3Sum

扩展题型为Three Sum，原题链接3Sum

要求和2Sum差不多，区别在于是三个数的和，target为0，同时会有多个解，而且最要命的是竟然可以有重复的元素。

吸收了2Sum的教训，聪明的boy可能想这里我也要用unordered_map，于是乎写出如下代码

class Solution {
public:vector<vector<int>> threeSum(vector<int>& nums) {/* 为了处理重复元素，首先排序nums */std::sort(nums.begin(), nums.end());vector<vector<int>> ans;unordered_map<int, int> hash;for(int i = 0; i < nums.size() - 2; ++i){int target = -nums[i];hash.clear();for(int j = i + 1; j < nums.size(); ++j){int ntarget = target - nums[j];if(hash.find(ntarget) != hash.end()){ans.push_back({nums[i], nums[j], ntarget});/* * 如果后面几个元素和当前元素重复，直接跳过，为什么可以直接跳过呢* 如果nums[j] == nums[j + 1]，那么当j++后仍然求出的是当前结果，因为* ntarget只可以是在nums[j]前面的数*/while(j < nums.size() && nums[j + 1] == nums[j])++j;}elsehash[nums[j]] = j;     }/* 同理 */while(i < nums.size() - 2 && nums[i] == nums[i + 1])++i;}return ans;}
};

于是乎兴奋的submit，却发现，额….

效率低的吓人，为什么呢，因为即使这样，仍然有着O(n2)的复杂度，唔…又开始进入优化的坑
对于现实主义者的我们来说O(n)是不可能了，和O(nlogn)有关的二分法好像也不太适用。首先判断肯定是要固定一个之后再遍历一遍，因为仍然有两个数是不确定的。

这里引入一种方法，模仿二分发left和right的移动。因为序列是有序的，那么仅仅需要判断nums[i + 1]和nums[nums.size() - 1]的和，从而得知是大（向左移），小（向右移动）

int left = 0;
int right = nums.size() - 1;
while(left < right)
{if(nums[left] + nums[right] > target)--right;else if(nums[left] + nums[right] < target)++left;else{/* 结果中的一员 push到结果中*//* 防止重复 */while(left < right && nums[left] == nums[left + 1])++left;while(left < right && nums[right] == nums[right - 1])--right;/* * 为什么这里需要++和--* 此时left是最后一个和之前的nums[left]重复的下标，需要++到第一个不重复的下标* 因为nums[left]已经改变，nums[left] + nums[right]不可能再等于target，所以right无需保持在最后一个和之前nums[right]重复的位置，也向前移动--* /++left;--right;}
}

利用这种方法的效率比上面高一些，可能原因就在于是从两边同时向中间移动，但是仍然摆脱不了O(n3)的复杂度（我一直以为上面的方法可以达到O(logn)….错了好久），代码如下

class Solution {
public:vector<vector<int>> threeSum(vector<int>& nums) {std::sort(nums.begin(), nums.end());vector<vector<int>> ans;for(int i = 0; i < nums.size(); ++i){int target = -nums[i];int left = i + 1;int right = nums.size() - 1;while(left < right){if(nums[left] + nums[right] > target)--right;else if(nums[left] + nums[right] < target)++left;else{ans.push_back({nums[i], nums[left], nums[right]});while(left < right && nums[left] == nums[left + 1])++left;while(left < right && nums[right] == nums[right - 1])--right;++left;--right;}}while(i < nums.size() - 2 && nums[i] == nums[i + 1])++i;}return ans;}
};

此时可能回想，2Sum我能不能也使用这种方法提高效率呢，想法是好的，可是要求是有序数组，而基于比较的最快的排序快排也只能是O(nlogn)，显然得不偿失

4Sum

最后一个扩展为4Sum，原题链接4Sum

和3Sum完全一样，只是4个数的和，代码也类似，不再强调了。
唔…leetcode上的解法也都是O(n3)，既然都这样就不想优化了

3Sum Closest

原题链接3Sum Closest

意思是给定一个数组，求数组中哪三个数的和最接近target，返回三个数的和。
这道题和3Sum是一样的，利用上面的思想，固定一个，剩下两个从两边开始找即可，当然需要排好序，代码如下

class Solution {
public:int threeSumClosest(vector<int>& nums, int target) {std::sort(nums.begin(), nums.end());int min_dis = INT_MAX;int three_sum = 0;for(int i = 0; i < nums.size(); ++i){int left = i + 1;int right = nums.size() - 1;while(left < right){/* 多出一部分用于比较和target的距离，记录和 */int sum = nums[i] + nums[left] + nums[right];if(abs(sum - target) < min_dis){three_sum = sum;min_dis = abs(sum - target);}if(sum > target)--right;else if(sum < target)++left;elsereturn sum;}}return three_sum;}
};

注：多数代码都在这里直接手打的，难免有错误，轻喷