LEETCODE解法笔记 —— 15 三数之和 & 18 四数之和

最新推荐文章于 2023-02-22 20:59:34 发布

overflow_1

最新推荐文章于 2023-02-22 20:59:34 发布

阅读量171

点赞数

分类专栏：刷题经验文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/overflow_1/article/details/113715909

版权

刷题经验专栏收录该内容

4 篇文章

订阅专栏

这篇博客探讨了如何使用排序和双指针技术解决寻找数组中多个数之和的问题。作者提供了C++代码实现，包括解决三数之和和四数之和的案例，并讨论了如何通过比较前驱来有效去重，以降低时间复杂度。此外，还提到了如何通过递归方法扩展到N数之和的寻找。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这个可以扩展到n数之和

时间复杂度如果暴力匹配的话可以达到O(N^n)

基本上首先需要sort给的数据，这样复杂度就会变成 O(N^(n-1)) ，快速排序的复杂度 O(nlogn)在大O表示法中被省去

如果sort之后，整个数据有序了，我们就可以指定前 N-2个，然后通过左右夹逼的方式，找出剩下的2个数，如果时暴力查找的话复杂度时O(n^2),但是现在是O(n)

这个实现起来其实很简单，但是一个问题是去重，给出的N元组合可能重复。

可以建一个set来暴力去重，但是效率比较低。可以采取和前驱对比的方法。

下面上代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        if (nums.size() < 3) return res;
        sort(nums.begin(),nums.end());

        for (int i = 0; i < nums.size()-2; i++)
        {
            int left = i + 1;
            int right = nums.size() -1;
            if (i > 0 && nums[i] == nums[i - 1]) continue;  //去重
            while (left < right)
            {
                if (nums[left]+nums[right] == -nums[i])
                {
                    vector<int> tmp = {nums[i],nums[left],nums[right]};

                    res.push_back(tmp);

                    left++;
                    right--;
                    while (left < right && nums[left] == nums[left - 1]) left++;  //去重
                    while (left < right && nums[right] == nums[right + 1]) right--;  //去重
                }
                else if (nums[left]+nums[right] < -nums[i])
                {
                    left++;
                }
                else
                {
                    right--;
                }
            }
        }
        return res;
    }
};

注意标着去重注释的那几行。

都是在和前驱做比较，如果和前驱一样，这次循环就跳过了，比如如果三元组的第一个数字遍历到[...4，4]，这里如果要避免重复三元组肯定不能选两次4。因为数据集是有序的，所以这样和前驱对比就能去重。

下面是4数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;
        if (nums.size() < 4) return res;
        for (int i = 0; i < nums.size()-3; i++)
        {
            if (i  > 0 && nums[i] == nums[i-1]) continue;  //去重
            for (int j = i+1; j < nums.size()-2; j++)
            {
                if (j > i+1 && nums[j] == nums[j-1]) continue; //去重
                int left = j+1;
                int right = nums.size()-1;
                while (left < right)
                {
                    int sum = nums[i]+nums[j]+nums[left]+nums[right];
                    if (sum == target)
                    {
                        vector<int> tmp = {nums[i],nums[j],nums[left],nums[right]};
                        res.push_back(tmp);
                        left++;
                        right--;
                        while (left < right && nums[left-1] == nums[left]) left++;  //去重
                        while (left < right && nums[right+1] == nums[right]) right--; //去重
                    }
                    else if (sum < target)
                    {
                        left++;
                    }
                    else
                    {
                        right--;
                    }
                }
            }
        }
        return res;
    }
};

偷懒就多套了一个循环，实际上可以改成递归来支持N数之和的寻找

 if (j > i+1 && nums[j] == nums[j-1]) continue;

上面这句最开始错了，写成 j > 0，抄错了,要从i + 1开始。