每天一道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};
            else
                hash[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;
                }
                else
                    hash[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;
                else
                    return sum;
            }
        }

        return three_sum;
    }
};

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