【LeetCode18. 四数之和】——双指针法

木瓜星灵TT

于 2022-11-20 15:46:08 发布

阅读量163

点赞数 1

分类专栏： LeetCode学习笔记文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/weixin_51630192/article/details/127949858

版权

LeetCode学习笔记专栏收录该内容

37 篇文章 0 订阅

订阅专栏

18. 四数之和

给你一个由 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

思考：

本题在之前三数之和的基础上，进一步拓展，求解四数之和，并且附加了新的条件，即求解的是四数和为target，而不是之前的0了。这个新条件的加入，让我们在进行去重操作时又要多留一个心眼。而四数之和的求解，其实只需在三数之和的外层再添加一层for循环，通过两层循环再加上左右双指针即可求解。

双指针法：

首先还是进行排序操作，接着开始编写最外层for循环：

for (int i = 0; i < nums.size(); i++)
        {
            if (nums[i] > target && (nums[i]>=0||target>=0)) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

值得注意的是，此处的if条件判断不同于之前的nums[i]>0，此处的target也有可能是负值，当出现例如-5,-4,-3,-2 而target为-6的情况时，就不能简单的通过nums[i]>target去除该种情况。

接着，类似的，便是第二层内层循环：

for (int j = i+1; j < nums.size(); j++)
            {
                if (nums[j]+nums[i] > target && (nums[j]+nums[i]>=0||target>=0)) {
                    break;
                }
                if (j > i+1 && nums[j] == nums[j - 1]) {
                    continue;
                }

在内层循环中，接下来就是和三数求解时一模一样的左右指针。要注意的是，当判断nums[i]+nums[j]+(nums[left] + nums[right]> target时，会出现溢出的问题应当改为nums[i]+nums[j]> target-(nums[left] + nums[right])，避免溢出。

完整代码：

#include<iostream>
#include<vector>
#include<algorithm>
#include<unordered_set>

using namespace std;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        //排序操作
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++)
        {
            if (nums[i] > target && (nums[i]>=0||target>=0)) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i+1; j < nums.size(); j++)
            {
                if (nums[j]+nums[i] > target && (nums[j]+nums[i]>=0||target>=0)) {
                    break;
                }
                if (j > i+1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.size() - 1;
                while (right > left) {
 
                    if (nums[i]+nums[j]> target-(nums[left] + nums[right])) {
                        right--;
 
                        while (left < right && nums[right] == nums[right + 1]) right--;
                    }
                    else if (nums[i]+nums[j] < target - (nums[left] + nums[right])) {
                        left++;
 
                        while (left < right && nums[left] == nums[left - 1]) left++;
                    }
                    else {
                        result.push_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++;

                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
};