Two Pointers/hash/3Sum/4Sum类题目

当结果不唯一的时候，使用STL去重的最简单方式是

std::sort(res.begin(), res.end());
res.erase(unique(res.begin(), res.end()), res.end());

首先是2Sum题目，构建一个hash表查找数的对应下标，求两个数的和，找到剩余差去hash查找。

https://leetcode.com/problems/two-sum/

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map <int,int> mapping;
        vector<int> result;
        for(int i=0;i<nums.size();i++)
            mapping[nums[i]]=i;
        for(int i=0;i<nums.size();i++)
        {
            const int gap=target-nums[i];
            if(mapping.find(gap)!=mapping.end() && mapping[gap]>i)
            {
                result.push_back(i+1);
                result.push_back(mapping[gap]+1);
            }
        }
        return result;
    }
};

对于3Sum题目，使用夹逼法，移动两个指针跳过重复的数字。

https://leetcode.com/problems/3sum/

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        vector<vector<int> > res;
        std::sort(num.begin(), num.end());
        for (int i = 0; i < num.size(); i++) {
            int target = -num[i];
            int front = i + 1;
            int back = num.size() - 1;
            while (front < back) {
                int sum = num[front] + num[back];
                // Finding answer which start from number num[i]
                if (sum < target)
                    front++;
                else if (sum > target)
                    back--;
                else {
                    res.push_back({num[i],num[front],num[back]});
                    // Processing duplicates of Number 2
                    // Rolling the front pointer to the next different number forwards
                    front++;
                    while (front < back && num[front] == num[front-1]) front++;
                    // Processing duplicates of Number 3
                    // Rolling the back pointer to the next different number backwards
                    back--;
                    while (front < back && num[back] == num[back+1]) back--;
                }
            }
            // Processing duplicates of Number 1
            while (i + 1 < num.size() && num[i + 1] == num[i]) i++;
        }
        return res;
    }
};

对于4Sum题目，首先可以使用夹逼法，可以看出这个可以推广到NSum，另外可以结合hash进行搜索。

https://leetcode.com/problems/4sum/

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        if (num.empty())
            return res;
        std::sort(num.begin(),num.end());
        for(int i=0;i<num.size();i++)
        {
            int target_3 = target - num[i];
            for(int j=i+1;j<num.size();j++)
            {
                int target_2 = target_3 - num[j];
                int front = j+1;
                int back = num.size() - 1;
                
                while(front < back)
                {
                    int two_sum=num[front]+num[back];
                    if(two_sum < target_2){
                        front ++;
                    }
                    else if (two_sum > target_2){
                        back --;
                    }
                    else{
                        res.push_back({num[i],num[j],num[front],num[back]});
                        front++;
                        back--;
                        // Processing the duplicates of number 3
                        while(front < back && num[front]==num[front-1]) front++;
                        // Processing the duplicates of number 4
                        while(front < back && num[back]==num[back+1]) back--; 
                    }
                }
                // Processing the duplicates of number 2
                while(j + 1 < num.size() && num[j + 1] == num[j]) ++j;
            }
            // Processing the duplicates of number 1
            while(i + 1 < num.size() && num[i + 1] == num[i]) ++i;
        }
        return res;
    }
};

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& num, int target) {
        vector<vector<int>> result;
        if (num.size() < 4) return result;
        sort(num.begin(), num.end());

        unordered_map<int,vector<pair<int,int> > > cache;
        
        for(int a=0;a<num.size();a++)
        {
            for(int b=a+1;b<num.size();b++)
            {
                cache[num[a]+num[b]].push_back(pair<int,int>(a,b));
            }
        }
        
        for(int c=0;c<num.size();c++)
        {
            for(int d=c+1;d<num.size();d++)
            {
                int key=target-num[c]-num[d];
                if(cache.find(key) == cache.end()) continue;
                const auto& vec = cache[key];
                for(int k=0;k<vec.size();++k)
                {
                    if(c<=vec[k].second)
                    {
                        continue;
                    }
                    result.push_back( {num[vec[k].first],num[vec[k].second],num[c],num[d]} );
                }
            }
        }
        sort(result.begin(), result.end());
        result.erase(unique(result.begin(), result.end()), result.end());
        return result;
    }
};

参考解答

灵魂机器leetcode解答https://github.com/soulmachine/leetcode

https://leetcode.com/discuss/27198/solution-explanation-comparison-problem-easy-understand

https://leetcode.com/discuss/23595/share-my-solution-around-50ms-with-explanation-and-comments