3Sum & 3Sum Closest & 4Sum

简单延续2sum的做法，用循环，不过代码比较长。原本很多地方写了break，后来发现都不应该加。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        vector<vector<int> > res;
        int n=num.size();
        if (n<=2) return res;
        sort(num.begin(),num.end());
        int pret=-999;
        for (int i=0; i<n-2; i++) {
            if (num[i]==num[i-1] && i>0) {
                continue;
            }
            int target = 0-num[i];
            map<int, int> m;
            for (int j=i+1; j<n; j++) {
                while (num[j]==num[j-1] && j<n && pret==target) {
                    j++;
                }
                if (j==n) break;
                if (m.find(num[j])!=m.end()) {
                    vector<int> cur;
                    cur.push_back(num[i]);
                    cur.push_back(m[num[j]]);
                    cur.push_back(num[j]);
                    res.push_back(cur);
                    pret=target;
                }else {
                    m[target-num[j]]=num[j];
                }
            }
        }
        return res;
    }
};

3Sum Closest

O(n^2)，内层循环和Container With Most Water的思路相同 

class Solution {
public:
    int threeSumClosest(vector<int> &num, int target) {
        int n=num.size();
        if (!n) return 0;
        sort(num.begin(),num.end());
        int min=9999;
        int res=0;
        for (int i=0; i<n; i++) {
            int j=i+1, k=n-1;
            while (j<k) {
                int cur=num[i]+num[j]+num[k];
                if (abs(cur-target)<min) {
                    min=abs(cur-target);
                    res=cur;
                }
                if (cur==target) {
                    return target;
                }else if(cur>target) {
                    k--;
                }else {
                    j++;
                }
            }
        }
        return res;
    }
};

4Sum

O(n^3)

use sort erase and unique to remove duplicates in a vector

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        int n=num.size();
        vector<vector<int>> res;
        if (!n) return res;
        sort(num.begin(), num.end());
        for (int i=0; i<n-3; i++) {
            for (int j=i+1; j<n-2; j++) {
                int k=j+1, l=n-1;
                while (k<l) {
                    int cur=num[i]+num[j]+num[k]+num[l];
                    if (cur==target) {
                        vector<int> temp;
                        temp.push_back(num[i]);
                        temp.push_back(num[j]);
                        temp.push_back(num[k]);
                        temp.push_back(num[l]);
                        res.push_back(temp);
                        do
                            k++;
                        while (num[k]==num[k-1]);
                        do
                            l--;
                        while (num[l]==num[l+1]);
                    }else if (cur>target) {
                        do
                            l--;
                        while (num[l]==num[l+1]);
                    }else {
                        do
                            k++;
                        while (num[k]==num[k-1]);
                    }
                }
            } 
        }
        sort(res.begin(), res.end() );
        res.erase( unique( res.begin(), res.end() ), res.end() );
        return res;
    }
};