【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, 127773);

_Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
if (_Qrem.rem < 0)
_Qrem.rem += 2147483647;
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() < 4)
return result;
int size = num.size();
sort(num.begin(), num.end());
map<vector<int>, bool> m;
for(int i = 0; i < size-3; i ++)
{
for(int j = i+1; j < size-2; j ++)
{
int k = j+1;    //k < size-1
int l = size-1;
while(k < l)
{
int sum = num[i]+num[j]+num[k]+num[l];
if(sum == target)
{
vector<int> cur(4,0);
cur[0] = num[i];
cur[1] = num[j];
cur[2] = num[k];
cur[3] = 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 = 0; i < size; i ++)
{
//skip same i
while(i > 0 && i < size && num[i] == num[i-1])
i ++;
for(int j = i+1; j < size; j ++)
{
//skip same j
//attention: the first element (num[i+1]) should not be skipped
while(j > i+1 && j < size && num[j] == num[j-1])
j ++;

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