OJ刷题日记：2、双指针（2）

目录

1、11.盛最多的水

2、LCR 179.查找总价格为目标值的两个商品

3、15.三数之和

4、18.四数之和

---

1、11.盛最多的水

题目：

11. 盛最多水的容器 - 力扣（LeetCode）https://leetcode.cn/problems/container-with-most-water/description/

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

• n == height.length
• 2 <= n <= 105
• 0 <= height[i] <= 104

从上方题目可以看出这个题目相当于求一个面积，面积的长是两个坐标之间的距离，高是两个坐标的数据中短的这个，所以就可以使用双指针算法去求，这里就是直接是利用左右两边的边作为左右指针，然后在创建一个值用来记录最大的面积，在left小于right的时候进入循环，然后进行计算，如果左边坐标的数据比右边坐标的数据小的时候，就进行计算，right-left*坐标小的数据就是这个面积，然后判断之前定义的tmp是否比面积小，如果小就把n的值给给tmp，然后left++，反之一样就是right--，如下方代码所示。

class Solution {
public:
    int maxArea(vector<int>& height) {
        int left=0;
        int right=height.size()-1;;
        int tmp=0;
        while(left<right)
        {
            if(height[left]<height[right])
            {
                int n=height[left]*(right-left);
                if(tmp<n)
                tmp=n;
                left++;
            }
            else
            {
                int n=height[right]*(right-left);
                if(tmp<n)
                tmp=n;
                right--;
            }
        }
        return tmp;
    }
};

2、LCR 179.查找总价格为目标值的两个商品

题目：
LCR 179. 查找总价格为目标值的两个商品 - 力扣（LeetCode）https://leetcode.cn/problems/he-wei-sde-liang-ge-shu-zi-lcof/description/

购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。

示例 1：

输入：price = [3, 9, 12, 15], target = 18
输出：[3,15] 或者 [15,3]

示例 2：

输入：price = [8, 21, 27, 34, 52, 66], target = 61
输出：[27,34] 或者 [34,27]

提示：

• 1 <= price.length <= 10^5
• 1 <= price[i] <= 10^6
• 1 <= target <= 2*10^6

先看题目，这里是一个升序的数组，在这里左边最小右边最大，然后找出两个价格刚好等于target，所以这里就可以进行双指针判断，这里就和上题差不多，定位左右两个边界，然后进行循环判断，两个坐标的值相加等于target的时候就返回这两个值，如果大于就--right，因为右边的值大，如果小于就++，代码测试如下。

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
        int left=0;
        int right=price.size()-1;
        while(left<right)
        {
            int sum=price[left]+price[right];
            if(sum==target)
            {
                return {price[left],price[right]};
            }
            else if(sum>target)
            {
                right--;
            }
            else 
            {
                left++;
            }
        }
        return {-1,-1};
    }
};

3、15.三数之和

15. 三数之和 - 力扣（LeetCode）https://leetcode.cn/problems/3sum/submissions/523534003/

给你一个整数数组 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 。

首先看题目就是返还三个数相加等于0 的三个数据，并且不能重复，这里就借用上题的思路是升序的数组进行计算这样就方便使用，如下图一就是定住最大的数据，然后进行如图的数组中进行判断，left+right=-i，也就是target，然后进行这样判断进行挪动数据这样就可以得出哪几个数据需要记录，如果有重复的数据就需要去重，这里使利用判断left-1==left的时候left就++，但是要注意边界问题，代码如下。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ret;
        sort(nums.begin(),nums.end());
        int n=nums.size();
        for(int i=0;i<n;)
        {
            int left=i+1;
            int right=n-1;
            int 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--;
                    while(left<right&&nums[left]==nums[left-1])
                    {
                        left++;
                    }
                    while(left<right&&nums[right]==nums[right+1])
                    {
                        right--;
                    }
                }
            }
            i++;
            while(i<n&&nums[i]==nums[i-1])
            {
                i++;
            }
        }
        return ret;
    }
};

4、18.四数之和

题目：

18. 四数之和 - 力扣（LeetCode）https://leetcode.cn/problems/4sum/description/

给你一个由 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就是target-i-j然后如果等于剩下的两个数就是需要的四个数，然后就是注意边界的问题，代码如下，就不多说了。

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;)
        {
            for(int j=i+1;j<n;)
            {
                int left=j+1;
                int 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)
                    {
                        left++;
                    }
                    else if(sum>aim)
                    {
                        right--;
                    }
                    else
                    {
                        ret.push_back({nums[i],nums[j],nums[left],nums[right]});
                        left++;
                        right--;
                        while(left<right && nums[left]==nums[left-1])left++;
                        while(left<right && nums[right]==nums[right+1])right--;
                    }
                }
                j++;
                while(j<n && nums[j]==nums[j-1])j++;
            }
            i++;
            while(i<n && nums[i]==nums[i-1])i++;
        }
        return ret;
    }
};