leetcode-18 4Sum

Given an array S of n integers, are there elements a; b; c, and d in S such that a+b+c+d = target?

Find all unique quadruplets in the array which gives the sum of target.

Note:

• Elements in a quadruplet (a; b; c; d) must be in non-descending order. (ie, a  b  c  d)

• The solution set must not contain duplicate quadruplets.

For example, given array S = {1 0 -1 0 -2 2}, and target = 0.

A solution set is:

(-1, 0, 0, 1)  (-2, -1, 1, 2)  (-2, 0, 0, 2)

思路1：

先排序，外面两层循环，里面左右夹逼，时间O(n^3)，空间O(1)，但是此方法会超时

思路2：

可以用一个hashmap先记录所有两个数的和index，再遍历hashmap寻找互补的和，时间平均O(n^2)，最坏O(n^4)，空间O(n^2)，也适用于3Sum。

//

// start: find all four numbers which gives the sum of zero

/************************************************************************/

/* method1:  for index with two for and left and right pointer       */

/************************************************************************/

vector<vector<int>> fourSum(vector<int>& num, int target)

{

    vector<vector<int>> result;

    if(num.size() < 4)

        return result;

    sort(num.begin(), num.end());  // first: sort

    int len = num.size();

    for(int i = 0; i < len; i++)

        for(int j = i+1; j < len; j++)

        {

            int k = j + 1;

            int l = len - 1;

            while(k < l)  

            {

                if(num[i]+num[j]+num[k]+num[l] < target)

                    k++

                else if(num[i]+num[j]+num[k]+num[l] > target)

                    l--;

                else

                {

                    result.push_back({num[i], num[j], num[k], num[l]});

                    k++;

                    l--;

                }

            }

        }

        // remove

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

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

        return result;

}

/************************************************************************/

/* method2:  for index with two for and left and right pointer       */

/************************************************************************/

vector<vector<int>> fourSum_HashMap(vector<int>& num, int target)

{

    vector<vector<int>> result;

    if(num.size() < 4)

        return result;

    sort(num.begin(), num.end());  // first: sort

    int len = num.size();

    unordered_map<int, vector<pair<int, int> > > cache;  // 当key相同时会进行push_back

    for(int i = 0; i < len; i++)

        for(int j = i+1; j < len; j++)

        {

            cache[num[i]+num[j]].push_back(pair<int, int>(i, j));

        }

    for(int i = 0; i < len; i++)

        for(int j = i+1; j < len; j++)

        {

            const int key = target - num[i] - num[j]; // num[i]和num[j]是后面两个

            if(cache.find(key) == cache.end())

                continue;

            const auto& pairs = cache[key];

            for(int k = 0; k < pairs.size(); k++)  

            {

                if(i < pairs[k].second)  // 有重叠(这里pairs[k].second是abcd中的b，i,j为待找的c,d)

                    continue;   // ??? < or <=

                result.push_back({num[pairs[k].first], num[pairs[k].second], num[i], num[j]});

            }

        }    

        // remove

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

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

        return result;

}

// end

//