优化算法：四元组求和问题的双指针优化解法-CSDN博客

本文链接：https://blog.csdn.net/weixin_44205193/article/details/121713553

本文探讨了一种改进的双指针策略，解决给定整数数组中找到所有和为目标值的不重复四元组问题，时间复杂度降低到 O(n^3)，有效避免了回溯法的超时问题。

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

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按任意顺序返回答案。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

一、回溯

看到这道题时我首先想到的是回溯法来解

class Solution {
public:
    vector<vector<int>> ans;
    
    vector<int> t;
    int Sum(vector<int>& t){
        int sum = 0;
        for(int i = 0; i < t.size(); i++){
            sum += t[i];
        }
        return sum;
    }
    void backtrack(vector<int>& nums, int target, vector<bool>& used,int start){
        if(t.size() == 4&&Sum(t) == target){
            ans.emplace_back(t);
            return;
        }
        
        for(int i = start; i < nums.size(); i++){
            if(i>0 && nums[i] == nums[i-1] && used[i-1] == false){
                continue;
            }
            if(used[i] ==false){
                t.emplace_back(nums[i]);
                used[i] = true;
                backtrack(nums,target,used,i+1);
                t.pop_back();
                used[i] = false;
            }
        }
    }
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<bool> used(200,false);
        backtrack(nums,target,used,0);
        return ans;
    }
};

在第218个测试是，结果果不其然运行超时

时间复杂度为O(4^n)

二、双指针

于是进行了改进，采用双指针来解

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        for(int i = 0; i < nums.size(); i++){
            if(i > 0 && nums[i] == nums[i-1])
            continue;
            for(int j = i+1; j < nums.size(); j++){
                if(j > i+1 && nums[j] == nums[j-1])
                continue;
                int left = j+1, right = nums.size()-1;
                while(left < right){
//注意这里不能让nums[i] + nums[j]+nums[left]+nums[right]，因为相加会超过int范围              
                if(nums[i] + nums[j] == target-(nums[left]+nums[right])){                           
                        ans.emplace_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;
                        left++;
                        right--;
                }
               
                if(nums[i] + nums[j] > target-(nums[left]+nums[right]))
                right--;
                if(nums[i] + nums[j] < target-(nums[left]+nums[right]))
                left++;
                }
            }
        }
        return ans;
    }
};