18. 4Sum

最新推荐文章于 2021-04-19 21:52:06 发布

原创最新推荐文章于 2021-04-19 21:52:06 发布 · 848 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一种解决四数之和问题的高效算法。该算法通过先排序再使用双指针技巧，将时间复杂度降低到O(n^3)，并确保了结果中没有重复的四元组组合。此外，文章还提供了详细的C++实现代码。

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

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)

和3Sum思想一样，这个复杂度是O(n^3)

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {

        vector<vector<int> > res;

        if (num.empty())
            return res;

        std::sort(num.begin(),num.end());

        for (int i = 0; i < num.size(); i++) {

            int target_3 = target - num[i];

            for (int j = i + 1; j < num.size(); j++) {

                int target_2 = target_3 - num[j];

                int front = j + 1;
                int back = num.size() - 1;

                while(front < back) {

                    int two_sum = num[front] + num[back];

                    if (two_sum < target_2) front++;

                    else if (two_sum > target_2) back--;

                    else {

                        vector<int> quadruplet(4, 0);
                        quadruplet[0] = num[i];
                        quadruplet[1] = num[j];
                        quadruplet[2] = num[front];
                        quadruplet[3] = num[back];
                        res.push_back(quadruplet);

                        // Processing the duplicates of number 3
                        while (front < back && num[front] == quadruplet[2]) ++front;

                        // Processing the duplicates of number 4
                        while (front < back && num[back] == quadruplet[3]) --back;

                    }
                }

                // Processing the duplicates of number 2
                while(j + 1 < num.size() && num[j + 1] == num[j]) ++j;
            }

            // Processing the duplicates of number 1
            while (i + 1 < num.size() && num[i + 1] == num[i]) ++i;

        }

        return res;

    }
};