leetcode - 4Sum_4sum leetcode 超时-优快云博客

本文链接：https://blog.youkuaiyun.com/le119126/article/details/46432039

本文详细介绍了如何在一个整数数组中找到四个元素的组合，使得它们的和等于指定的目标值。文章包括算法实现、注意事项及避免重复解的方法，通过实例演示了如何高效解决此类问题。

摘要生成于 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)

#include 
#include 
#include 
#include 

using namespace std;

class Solution {
public:
    vector< vector > fourSum(vector& nums, int target) {
        sort(nums.begin(),nums.end());
        int len=nums.size();
                vector< vector > retVec;
                for(int i=0;i0 && nums[i]==nums[i-1]) //一定要i>0 && ums[i]==nums[i-1] 而不能 ums[i]==nums[i+1]----如果这样j=i+1就少了一次
                        {
                                continue;//防止重复
                        }
                        for(int j=i+1;ji+1 && nums[j]==nums[j-1])
                                {
                                        continue;
                                }
                                int k=j+1;
                                int m=len-1;
                                while(kj+1 && nums[k]==nums[k-1]) //防止重复
                                        {
                                                k++;
                                                continue;
                                        }
                                        if(mtarget)
                                                m--;
                                        else
                                        {
                                                vector tmp;
                                                tmp.push_back(nums[i]);
                                                tmp.push_back(nums[j]);
                                                tmp.push_back(nums[k]);
                                                tmp.push_back(nums[m]);
                                                retVec.push_back(tmp);
                                                k++;
                                                m--;
                                        }
                                }
                        }
                }
                return retVec;
    }
};

int main()
{
        Solution s;
        vector nums;
        nums.push_back(-1);
        nums.push_back(0);
        nums.push_back(1);
        nums.push_back(2);
        nums.push_back(-1);
        nums.push_back(-4);
        cout<


注意：用3Sum中的递归算法会超时，时间复杂度应该都是O(n^3)，不明白