【LeetCode】18. 4Sum (2 solutions)

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)

先确定前两个数num[i],num[j]，

然后设置双指针k,l分别指向两端，往中间扫。

(1)(sum = num[i]+num[j]+num[k]+num[l]) == taget，则找到其中一个解。k++,l--.

(2)sum > target, l--

(3)sum < target, k++

解法一：

用map去重

注：不可以使用unordered_map,不然会报错：

error C2440: “类型转换”: 无法从“const std::vector<_Ty>”转换为“size_t”

根据unordered_map的源码来看：

    // TEMPLATE CLASS hash
template<class _Kty>
    class hash
        : public unary_function<_Kty, size_t>
    {    // hash functor
public:
    size_t operator()(const _Kty& _Keyval) const
        {    // hash _Keyval to size_t value by pseudorandomizing transform
        ldiv_t _Qrem = _CSTD ldiv((long)(size_t)_Keyval, );

        _Qrem.rem =  * _Qrem.rem -  * _Qrem.quot;
        if (_Qrem.rem < )
            _Qrem.rem += ;
        return ((size_t)_Qrem.rem);
        }
    };

key必须转换为size_t类型，对应于hash表下标。

保险起见，非内置类型就不要作为unordered_map的key了。

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > result;
        if(num.empty() || num.size() < )
            return result;
        int size = num.size();
        sort(num.begin(), num.end());
        map<vector<int>, bool> m;
        for(int i = ; i < size-; i ++)
        {
            for(int j = i+; j < size-; j ++)
            {
                int k = j+;    //k < size-1
                int l = size-;
                while(k < l)
                {
                    int sum = num[i]+num[j]+num[k]+num[l];
                    if(sum == target)
                    {
                        vector<int> cur(,);
                        cur[] = num[i];
                        cur[] = num[j];
                        cur[] = num[k];
                        cur[] = num[l];
                        if(m.find(cur) == m.end())
                        {
                            result.push_back(cur);
                            m[cur] = true;
                        }
                        k ++;
                        l --;
                    }
                    else if(sum > target)
                        l --;
                    else
                        k ++;
                }
            }
        }
        return result;
    }
};

解法二：

不用开辟新的空间，通过跳过已访问过的元素来去重。

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > ret;
        int size = num.size();
        sort(num.begin(), num.end());
        for(int i = ; i < size; i ++)
        {
            //skip same i
            while(i >  && i < size && num[i] == num[i-])
                i ++;
            for(int j = i+; j < size; j ++)
            {
                //skip same j
                //attention: the first element (num[i+1]) should not be skipped
                while(j > i+ && j < size && num[j] == num[j-])
                    j ++;

                int k = j + ;
                int l = size - ;
                while(k < l)
                {
                    int sum = num[i] + num[j] + num[k] + num[l];
                    if(sum == target)
                    {
                        vector<int> cur();
                        cur[] = num[i];
                        cur[] = num[j];
                        cur[] = num[k];
                        cur[] = num[l];
                        ret.push_back(cur);
                        k ++;
                        l --;
                        //skip same k
                        while(k < l && num[k] == num[k-])
                            k ++;
                        //skip same l
                        while(l > k && num[l] == num[l+])
                            l --;
                    }
                    else if(sum < target)
                    {
                        k ++;
                        //skip same k
                        while(k < l && num[k] == num[k-])
                            k ++;
                    }
                    else
                    {
                        l --;
                        //skip same l
                        while(l > k && num[l] == num[l+])
                            l --;
                    }
                }
            }
        }
        return ret;
    }
};