双指针--收尾的两道题

双指针

(封面起到吸引读者作用，和文章内容无关哈，但是文章也是用心写的）

三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

题目解析

算法原理

解法（排序+双指针）：

算法思路：

本题与两数之和类似，是⾮常经典的⾯试题。

与两数之和稍微不同的是，题⽬中要求找到所有「不重复」的三元组。那我们可以利⽤在两数之和 那⾥⽤的双指针思想，来对我们的暴⼒枚举做优化：

i. 先排序；

ii. 然后固定⼀个数 a ：

iii. 在这个数后⾯的区间内，使⽤「双指针算法」快速找到两个数之和等于 -a 即可。

但是要注意的是，这道题⾥⾯需要有「去重」操作~

i. 找到⼀个结果之后， left 和 right 指针要「跳过重复」的元素；

ii. 当使⽤完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素。

代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        //排序
        sort(nums.begin(),nums.end());
        vector<vector<int>> ret;//要有返回值
        int n=nums.size();
        for(int i=0;i<n; )//可以不写i++提高效率
        {
            //对代码进行优化，在于排完序后，正数不用考虑
            if(nums[i]>0) break;
            int left=i+1,right=n-1,target=-nums[i];
            while(left<right)
            {
            int sum=nums[left]+nums[right];
            
            if(sum>target) right--;
            else if(sum<target) left++;
            else {
                    ret.push_back({nums[i],nums[left],nums[right]});
                    left++,right--;
                //left<right防止越界
                    while(left<right&&nums[left]==nums[left-1]) left++;
                    while(left<right&&nums[right]==nums[right+1]) right--;
            }
            }
            //防止i重复
            i++;
            while(i<n&&nums[i]==nums[i-1]) i++;
        }
        return ret;
    }
};

四数之和

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

解法（排序 + 双指针）

算法思路：

a. 依次固定⼀个数 a ；

b. 在这个数 a 的后⾯区间上，利⽤「三数之和」找到三个数，使这三个数的和等于 target - a 即可。

代码如下：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector <vector<int>> ret;
        sort(nums.begin(),nums.end());
        int n=nums.size();
        for(int i=0;i<n; )//固定数字a
        {
            for(int j=i+1;j<n; )//固定数字b
            {
                int left=j+1,right=n-1;
                long long aim=(long long)target-nums[i]-nums[j];//需要强制类型转换
                while(left<right)
                {
                    int sum=nums[left]+nums[right];
                    if(sum>aim) right--;
                    else if(sum<aim) left++;
                    else{
                        ret.push_back({nums[i],nums[j],nums[left++],nums[right--]});
                        //去重1
                        while(left<right&&nums[left]==nums[left-1]) left++;
                        while(left<right&&nums[right]==nums[right+1]) right--;
                    }
                }
                //去重2
               j++;
               while(j<n&&nums[j]==nums[j-1]) j++;
            }
            //去重3
                i++;
                while(i<n&&nums[i]==nums[i-1]) i++;
        }
        return ret;
    }
};