LeetCode-018. 4Sum

1. 题目

4Sum

查找数组中和为０的４个数
解决方案集不能含有重复项

2. 分析

1：传统k-sum问题，先排序，再左右夹逼
时间复杂度O(n^3)，空间复杂度O(1)
2：借助unordered_multimap（允许重复key）缓存两数之和
时间复杂度O(n^2)，空间复杂度O(n^2)
注意内层循环是for(int j = i + 1; j < nums.size(); ++j)而非for(int j = 0; j < nums.size(); ++j)
a = i->second.first;而非a = i->first.first;
if(a != c && a != d && b != c && b != d)而非if(nums[a] + nums[b] + nums[c] + nums[d] == target)

3. 代码

1）

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        int len = nums.size();
        if(len < 4)
            return result;

        sort(nums.begin(), nums.end());

        for(int a = 0; a < len - 3; ++a)
        {
            for(int b = a + 1; b < len - 2; ++b)
            {
                int c = b + 1;
                int d = len - 1;

                while(c < d)
                {
                    if(nums[a] + nums[b] + nums[c] + nums[d] == target)
                    {
                        result.push_back({nums[a], nums[b], nums[c], nums[d]});
                        ++c;
                        --d;
                    }
                    else if(nums[a] + nums[b] + nums[c] + nums[d] < target)
                    {
                        ++c;
                    }
                    else
                    {
                        --d;
                    }
                }
            }
        }

        sort(result.begin(), result.end());
        result.erase(unique(result.begin(), result.end()), result.end());

        return result;
    }
};

2）

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        int len = nums.size();
        if(len < 4)
            return result;

        unordered_multimap<int, pair<int, int>> cache;
        for(int i = 0; i < len - 1; ++i)
        {
            for(int j = i + 1; j < len; ++j)
            {
                cache.insert(make_pair(nums[i] + nums[j], make_pair(i, j)));
            }
        }


        for(auto i = cache.begin(); i != cache.end(); ++i)
        {
            int gap = target - i->first;
            auto tag = cache.equal_range(gap);
            for(auto j = tag.first; j != tag.second; ++j)
            {
                int a = i->second.first;
                int b = i->second.second;
                int c = j->second.first;
                int d = j->second.second;

                if(a != c && a != d && b != c && b != d)
                {
                    vector<int> vec = {nums[a], nums[b], nums[c], nums[d]};
                    sort(vec.begin(), vec.end());
                    result.push_back(vec);
                }
            }   
        }

        sort(result.begin(), result.end());
        result.erase(unique(result.begin(), result.end()), result.end());

        return result;
    }
};