[LeetCode] 4Sum

算法渣，现实基本都参考或者完全拷贝[戴方勤(soulmachine@gmail.com)]大神的leetcode题解，此处仅作刷题记录。

 

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 (size_t a = 0; a < num.size(); a++){
            for (size_t b = a + 1; b < num.size(); b++) {
                cache[num[a] + num[b]].push_back(pair<int, int>(a, b)); // 对于某个和，可能存在多种组合，这些组合存储到一个向量中
            }
        }

        for (size_t c = 0; c < num.size(); c++) {
            for (size_t d = c + 1; d < num.size(); d++) {
                const int key = target - num[c] - num[d];
                if (cache.find(key) == cache.end())
                    continue;

                const auto& vec = cache[key];
                for (size_t 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;
    }
};

 

下面方法感觉更好

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_multimap<int, pair<int, int>>  cache;
        for (int i = 0; i + 1 < num.size(); ++i)
        for (int j = i + 1; j < num.size(); ++j)
            cache.insert(make_pair(num[i] + num[j], make_pair(i, j)));
        for (auto i = cache.begin(); i != cache.end(); ++i)  {
            int  x = target - i->first;
            auto  range = cache.equal_range(x);
            for (auto j = range.first; j != range.second; ++j)  {
                auto  a = i->second.first;
                auto  b = i->second.second;
                auto  c = j->second.first;
                auto  d = j->second.second;
                if (a != c  &&  a != d  &&  b != c  &&  b != d)  {
                    vector<int>  vec = { num[a], num[b], num[c], num[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;
    }
};

 

杂记:

1. pair

This class couples together a pair of values, which may be of different types (T1 and T2). The individual values can be accessed through its public members first and second.

Pairs are a particular case of tuple.

2. 其他方法用到的类 unordered_multimap

Unordered multimaps are associative containers that store elements formed by the combination of a key value and amapped value, much like unordered_map containers, but allowing different elements to have equivalent keys.

Elements with equivalent keys are grouped together in the same bucket and in such a way that an iterator (seeequal_range) can iterate through all of them.

3. insert

unordered_multimap没有[]运算符，必须以insert方式插入数据，而且插入式必须调用make_pair函数

4. equal_range

Get subrange of equal elements

Returns the bounds of the subrange that includes all the elements of the range [first,last) with values equivalent tova