Leetcode 数组题合集 18.FourSum

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

1. 对数组nums进行排序
   

2. 调用函数并传参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