Difficulty:Medium
Description
Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
Note:
The solution set must not contain duplicate quadruplets.
Example:
Given array nums = [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]
]
算法
首先是如何解决3数之和的, 3数之和是在2数之和的基础上包装一个外循环, 这个外循环有一个指针循环指向元素的值v, 通过它寻找数值对: 数值对之和等于target - v.
有两种方法:
1.双指针, 在一个排好序的数组里
2.哈希表.
总结
我们可以通过加一个外循环将3数之和进阶成4数之和, 同理,我们还可以解决5数之和, 6数之和等等.
真正核心的是kSum,
实现
双指针
此法需要数组被排好序.
然后需要解决重复问题: 重复的数相邻, 可以跳开.
对于3数之和, 我们单循环列举每个值, 使用双指针遍历剩下的值.
对k数之和, 我们使用k-2个嵌套的循环列举k-2个值的组合.
实现
我们可以递归实现k -2个循环, 我们传递开始开始起点和k作为参数, 当k==2时,终止循环.
1.For 4Sum function
-
对数组nums进行排序
- 调用函数并传参start = 0,k = 4, 和target, 然后返回结果
2.For kSum function:
-
检查k个最小值之和是否大于target, 或者k个最大值之和是否小于taget,
既然数组已经排好序了, 那么最小值就是numsp[start],
如果上述两种情况都符合, 那么结束循环 -
如果k==2, 调用twoSum并返回结果
-
从start开始迭代i
-
如果现在指向的值和前一个相同, 那么跳过
-
递归调用kSum传参start = i + 1, k = k - 1.target = target - numsp[i]
-
对于每个返回的set的值
- 将现在指向的值 nums[i] 放入 set
- 将 set 放入 最后返回的结果res
-
-
返回最终结果res
3.For twoSum function:
-
将指针lo 指向start, 指针hi指向最后一个数
-
当lo< hi:
-
如果nums[lo] + nums[hi] < target , 自增 lo
- 如果 nums[lo - 1] == nums[lo] 同样自增 lo
-
如果nums[lo] + nums[hi] > target, 自减hi
- 如果 nums[hi] == nums[hi+1]
-
最后, 找到这个数值对:
- 将它添加到res中
- 自减hi和自增lo
-
-
返回结果 res
C++代码
class Solution
{
public:
vector<vector<int>> fourSum(vector<int> &nums, int target)
{
sort(begin(nums), end(nums));
return kSum(nums, target, 0, 4);
}
vector<vector<int>> kSum(vector<int> &nums, int target, int start, int k)
{
vector<vector<int>> res;
//数组长度为1
//k个最小值>target
//k个最大值<target
if (start == nums.size() || nums[start] * k > target || target > nums.back() * k)
{
return res; //返回空集
}
//调用twoSum
if (k == 2)
{
return twoSum(nums, target, start);
}
for (int i = start; i < nums.size(); ++i)
{
if (i == start || nums[i - 1] != nums[i])
{
//递归调用kSum
for(auto &set : kSum(nums, target - nums[i], i + 1, k - 1)){
res.push_back({nums[i]});
//在end(res.back())即上一句生成的{nums[i]}中的nums[i]前插入set所有的元素
res.back().insert(end(res.back()), begin(set), end(set));
}
}
}
return res;
}
vector<vector<int>> twoSum(vector<int> &nums, int target, int start)
{
vector<vector<int>> res;
int lo = start, hi = nums.size() - 1;
while (lo < hi)
{
int sum = nums[lo] + nums[hi];
if(sum < target || (lo > start&& nums[lo] == nums[lo - 1])){
++lo;
}else if(sum > target || (hi < nums.size() - 1 && nums[hi] == nums[hi + 1])){
--hi;
}else{
res.push_back({nums[lo++], nums[hi--]});
}
}
return res;
}
};
时间复杂度
O(n ^(k-1)) , or O(n ^3) for 4Sum.
需要进行k - 2次循环, twoSum的复杂度为O(n)
当 k > 2时, 排序不能改变总体的时间复杂度
空间复杂度
O(n). 递归需要O(k)空间, k 是 算法最坏的情况时n的取值
注意 : 这里我们忽视了输出所需要的内存.
哈希表
可以使用哈希表一次遍历, 例如2sum:on-pass Hash Table
在3sum:hash set中(需要会员), 我们无需对数组排序就可解决问题. 为了实现它, 我们用三元组对值进行排序, 然后在哈希表中追踪.
对k个值进行同样的操作是不现实的
所以, 我们这里和双指针算法一样对数组进行排序,然后跳过重复值. 所以, 这里仅仅2sum部分的代码和上面不同.
实现
2sum部分的代码和Two Sum:One-pass Hash Table几乎一样 区别在于跳过重复值, 既然数组排序了, 我们仅需要比较res中的最后一个元素.
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
sort(begin(nums), end(nums));
return kSum(nums, target, 0, 4);
}
vector<vector<int>> kSum(vector<int>& nums, int target, int start, int k){
vector<vector<int>> res;
if (start == nums.size() || nums[start] * k > target || target > nums.back() * k)
return res;
if (k == 2)
return twoSum(nums, target, start);
for (int i = start; i < nums.size(); ++i)
if (i == start || nums[i - 1] != nums[i])
for (auto &set : kSum(nums, target - nums[i], i + 1, k - 1)) {
res.push_back({nums[i]});
res.back().insert(end(res.back()), begin(set), end(set));
}
return res;
}
vector<vector<int>> twoSum(vector<int>& nums, int target, int start){
vector<vector<int>> res;
unordered_set<int> s;
for(auto i = start; i < nums.size(); ++i){
//res为空
//能找target-nums[i],nums[i],但nums[i]==nums[i-1]
if(res.empty() || res.back()[1]!=nums[i])
if(s.count(target - nums[i]))
res.push_back({target - nums[i], nums[i]});
s.insert(nums[i]);
}
return res;
}
};
时间复杂度
O(n ^(k-1)) , or O(n ^3) for 4Sum.
对n个数需要进行k - 2次循环, twoSum的复杂度为O(n)
当 k > 2时, 排序不能改变总体的时间复杂度
空间复杂度
哈希表需要O(n).
递归造成哈希表的空间不超过O(n).
参考:4Sum