leetcode:2sum,2sumSorted,3sum,3sumClosest,4sum,4sumII.[哈希表，双指针]

2sum:哈希表，再寻求a+b=c过程中可使用哈希表，一次遍历O(n)即可，使用unordered_map<int,int>之find()方法，思路：不存在于表->进哈希表;存在于表，得结果。注意如果不存在，返回[-1,-1],考虑问题要面面俱到。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {// O(n),C++ STL hash-->unoredered_map
        vector<int> ret(2,-1);
        unordered_map<int,int> hash;
        for (int i = 0; i < nums.size(); ++i)
        {
            if(hash.find(target-nums[i])==hash.end())
            {
                hash[nums[i]]=i;
            }else
            {
                ret[0]=i;
                ret[1]=hash[target-nums[i]]
            }
        }
        return ret;
        

    }
};

2sumSorted:已排序好的数组，直接使用双指针i,j前后逼近，时间复杂度O(logn)。

class Solution {// array is alreay sorted,we use double pointers
public:
    vector<int> twoSum_sorted(vector<int>& numbers, int target) {
        vector<int> ret(2,-1);
        int i=0,j=numbers.size()-1;
        while(i<j)
        {
            if(numbers[i]+numbers[j]==target)
            {
                ret[0]=i+1;
                ret[1]=j+1;
                return ret;
            }else if(numbers[i]+numbers[j]<target)
            {
                i++;
            }else
            {
                j--;
            }
        }
        return ret;
    }
};

3sum:先排序，然后，固定前面的k,后面双指针i,j逼近，注意有重复值时，可跳跃重复值。代码结构中，不能先跳跃重复值，再求和，因为，如果i一直跳跃，可能把j逼的动不了，[0,-2,1,1,3]，i跳到1了，j无法跳到1.所以先求和，再跳跃！

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());

        for (int k = 0; k <nums.size(); ++k)
        {
            if(nums[k]>0) break;
            if(k>0&&nums[k]==nums[k-1]) continue;

            int i=k+1,j=nums.size()-1;
            while(i<j)
            {
                //while(i<j&&nums[i]==nums[i+1]) i++;   we can not find this first,beacuse an example [0,-2,1,1,3]
                //while(i<j&&nums[j]==nums[j-1]) j--;
                if(nums[i]+nums[j]==0-nums[k])
                {
                    res.push_back({(nums[k],nums[i],nums[j])});
                    while(i<j&&nums[i]==nums[i+1]) i++;
                    while(i<j&&nums[j]==nums[j-1]) j--;
                    i++;
                    j--;
                }else if(nums[i]+nums[j]<0-nums[k])
                {
                    j--;
                }else
                {
                    i++;
                }
            }
        }
        return res;


    }
};

3sumClosest:三数之和sum比target小，为了更靠近target，sum就要增大！（无论正负，靠近就是增大或减小）,不要想复杂了，跟二分逼近的原理一样的,擅长变通。

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int mindis=1000000;
        int res;
        for (int k = 0; k < nums.size(); ++k)
        {
            if(k>0&&nums[k]==nums[k-1]) continue;

            int i=k+1,j=nums.size()-1;
            int sum;
            while(i<j)// a little translation of question 3sum,be flexible
            {         // first i++ then j-- is not right,beacuse it skips many combinations .it doesn't cover all
                sum=nums[k]+nums[i]+nums[j];
                if(sum==target) return sum;
                else if(sum<target)
                {
                    if(target-sum<mindis)
                    {
                        mindis=target-sum;
                        res=sum;
                    }
                    i++;
                }else
                {
                    if(sum-target<mindis)
                    {
                        mindis=sum-target;
                        res=sum;
                    }
                    j--
                }

            }
        }

        return res;

    }
};

4sum:3sum外面套一层循环即可

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        set<vector<int>> setvec;
        sort(nums.begin(),nums.end());
        for (int p = 0; p < nums.size(); ++p)
        {
            for (int k = p+1; k < nums.size(); ++k)
            {
                int i=k+1,j=nums.size()-1;
                while(i<j)
                {
                    int sum=nums[p]+nums[k]+nums[i]+nums[j];//3sum +for=4sum
                    if(sum==target)
                    {
                        setvec.insert({nums[p],nums[k],nums[i],nums[j]});
                        while(i<j&&nums[i]==nums[i+1]) i++;
                        while(i<j&&nums[j]==nums[j-1]) j--;
                        i++;
                        j--;
                    }else if (sum<target) i++;
                    else j--;
                }
            }
        }

        set<vector<int>>::iterator it= setvec.begin();
        for(;it!=setvec.end();++it)
        {
            res.push_back(*it);
        }
        return res;

    }
};

4sumII:unordered_map的迭代器用法，for(auto a:m1) a.first a.second. 能用哈希表的尽量用哈希表

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        int res=0;
        int len=A.size();
        unordered_map<int,int>m1,m2;
        for (int i = 0; i < len; ++i)
        {
            for (int j = 0; j < len; ++j)
            {
                m1[A[i]+B[j]]++;
                m2[C[i]+D[j]]++;
            }
        }
        for (auto a:m1)//knowing how to use iterator of unordered_map
        {
            res+=a.second*m2[0-a.first];
        }
        return res;
    }
};