优选算法之双指针(下)

目录

一、有效三角形的个数

1.题目链接:611.有效三角形的个数

2.题目描述:

3.解法一(暴力求解、会超时)

🌵算法思路:

🌵算法代码:

4.解法二(排序 + 双指针)

🌵算法思路:

🌵算法代码:

二、和为 S 的两个数

1.题目链接:179.查找总价值为目标值的两个商品

2.题目描述:

3.解法一(暴力解法、会超时)

🍀算法思路:

🍀算法流程:

🍀算法代码:

4.解法二(双指针 - 对撞指针)

🍀算法思路:

🍀算法流程:

🍀算法代码:

三、三数之和

1.题目链接:15.三数之和

2.题目描述:

3.解法(排序 + 双指针)

🍁算法思路:

🍁算法代码:

四、四数之和

1.题目链接:18.四数之和

2.题目描述:

3.解法(排序 + 双指针)

🌾算法思路:

🌾算法代码:


一、有效三角形的个数

1.题目链接:611.有效三角形的个数

2.题目描述:

给定一个包含非负整数的数组 nums ,返回其中可以组成三角形三条边的三元组个数。

示例 1:

输入: nums = [2,2,3,4]
输出: 3
解释:有效的组合是: 
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3

示例 2:

输入: nums = [4,2,3,4]
输出: 4

3.解法一(暴力求解、会超时

🌵算法思路:

三层 for 循环枚举出所有的三元组,并且判断是否能构成三角形。

虽然说是暴力求解,但是还是想优化一下:

判断三角形的优化:

  • 如果能构成三角形,需要满足任意两边之和要大于第三边。但是实际上只需让较小的两条边之和大于第三边即可
  • 因此我们可以先将原数组排序,然后从小到大枚举三元组,一方面省去枚举的数量,另一方面方便判断是否能构成三角形。

🌵算法代码:

class Solution 
{
public:
    int triangleNumber(vector<int>& nums) 
    {
        // 1. 排序
        sort(nums.begin(), nums.end());
        int ret = 0, n = nums.size();
        // 2. 从⼩到⼤枚举所有的三元组
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                for(int k = j + 1; k < n; k++)
                {
                    // 当最⼩的两个边之和⼤于第三边的时候,统计答案
                    if(nums[i] + nums[j] > nums[k])
                    {
                        ret++;
                    }
                }
            }
        }
        return ret;
    }
};

4.解法二(排序 + 双指针

🌵算法思路:

先将数组排序。

根据「解法一」中的优化思想,我们可以固定一个「最长边」,然后在比这条边小的有序数组中找出一个二元组,使这个二元组之和大于这个最长边。由于数组是有序的,我们可以利用「对撞指针」来优化。

设最长边枚举到 i 位置,区间 [left, right] 是 i 位置左边的区间(也就是比它小的区间):

如果 nums[left] + nums[right] > nums[i] :

  • 说明 [left, right - 1] 区间上的所有元素均可以与 nums[right] 构成比nums[i] 大的二元组。
  • 满足条件的有 right - left 种。
  • 此时 right 位置的元素的所有情况相当于全部考虑完毕, right-- ,进入下一轮判断。

如果 nums[left] + nums[right] <= nums[i] :

  • 说明 left 位置的元素是不可能与 [left + 1, right] 位置上的元素构成满足条件的二元组。
  • left 位置的元素可以舍去, left++ 进入下轮循环。

🌵算法代码:

class Solution 
{
public:
    int triangleNumber(vector<int>& nums) 
    {
        // 优化
        sort(nums.begin(), nums.end());

        // 利用双指针解决问题
        int ret = 0, n = nums.size();
        for (int i = n - 1; i >= 2; i--)// 先固定最大的数
        {
            // 利⽤双指针快速统计符合要求的三元组的个数
            int left = 0, right = i - 1;
            while (left < right) 
            {
                if (nums[left] + nums[right] > nums[i]) 
                {
                    ret += right - left;
                    right--;
                } 
                else 
                {
                    left++;
                }
            }
        }
        return ret;
    }
};

二、和为 S 的两个数

1.题目链接:179.查找总价值为目标值的两个商品

2.题目描述:

购物车内的商品价格按照升序记录于数组 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]

3.解法一(暴力解法、会超时

🍀算法思路:

两层 for 循环列出所有两个数字的组合,判断是否等于目标值。

🍀算法流程:

两层 for 循环:

  • 外层 for 循环依次枚举第一个数 a ;
  • 内层 for 循环依次枚举第二个数 b ,让它与 a 匹配;
  • ps :这里有个魔鬼细节:我们挑选第二个数的时候,可以不从第一个数开始选,因为 a 前面的数我们都已经在之前考虑过了;因此,我们可以从 a 往后的数开始列举。
  • 然后将挑选的两个数相加,判断是否符合目标值。

🍀算法代码:

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int n = nums.size();
        // 第⼀层循环从前往后列举第⼀个数
        for (int i = 0; i < n; i++) 
        { 
            // 第⼆层循环从 i 位置之后列举第⼆个数
            for (int j = i + 1; j < n;j++) 
            { 
                if (nums[i] + nums[j] == target) 
                    return {nums[i], nums[j]};
            }
        }
        return {-1, -1};
    }
};

4.解法二(双指针 - 对撞指针

🍀算法思路:

注意到本题是升序的数组,因此可以「用对撞指针」优化时间复杂度。

🍀算法流程:

a. 初始化 left , right 分别指向数组的左右两端(这里不是我们理解的指针,而是数组的下标)。

b. 当 left < right 的时候,一直循环。

i. 当 nums[left] + nums[right] == target 时,说明找到结果,记录结果,并且返回;

ii. 当 nums[left] + nums[right] < target 时:

  • 对于 nums[left] 而言,此时 nums[right] 相当于是 nums[left] 能碰到的最大值(别忘了,这里是升序数组哈~)。如果此时不符合要求,说明在这个数组里面,没有别的数符合 nums[left] 的要求了(最大的数都满足不了你,你已经没救了)。因此,我们可以大胆舍去这个数,让 left++ ,去比较下一组数据;
  • 那对于 nums[right] 而言,由于此时两数之和是小于目标值的, nums[right]还可以选择比 nums[left] 大的值继续努力达到目标值,因此 right 指针我们按兵不动;

iii. 当 nums[left] + nums[right] > target 时,同理我们可以舍去 nums[right] (最小的数都满足不了你,你也没救了)。让 right-- ,继续比较下一组数据,而 left 指针不变(因为他还是可以去匹配比 nums[right] 更小的数的)。

🍀算法代码:

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

三、三数之和

1.题目链接:15.三数之和

2.题目描述:

给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != ji != 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.解法(排序 + 双指针

🍁算法思路:

本题与两数之和类似,是非常经典的面试题。

与两数之和稍微不同的是,题目中要求找到所有「不重复」的三元组。那我们可以利用在两数之和那里用的双指针思想,来对我们的暴力枚举做优化:

  1. 先排序;
  2. 然后固定一个数 a :
  3. 在这个数后面的区间内,使用「双指针算法」快速找到两个数之和等于 -a 即可。

但是要注意的是,这道题里面需要有「去重」操作~

  1. 找到一个结果之后, left 和 right 指针要「跳过重复」的元素;
  2. 当使用完一次双指针算法之后,固定的 a 也要「跳过重复」的元素。

🍁算法代码:

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ret;
        // 1.排序
        sort(nums.begin(), nums.end());
        // 2.利用双指针解决问题
        int n = nums.size();
        for(int i = 0; i < n; )// 固定数
        {
            // 如果数i大于0,那他的相反数肯定为负数,负数再取相反数则为正数,
            // 相加肯定不为0,所以直接跳出循环
            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--;
                    // 去重操作
                    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;
    }
};

四、四数之和

1.题目链接:18.四数之和

2.题目描述:

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

  • 0 <= a, b, c, d < n
  • abc 和 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]]

3.解法(排序 + 双指针

🌾算法思路:

  1. 依次固定一个数 a ;
  2. 在这个数 a 的后面区间上,利用「三数之和」找到三个数,使这三个数的和等于 target - a 即可。

🌾算法代码:

class Solution 
{
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) 
    {
        vector<vector<int>> ret;
        // 1.排序
        sort(nums.begin(), nums.end());
        // 2.利用双指针解决问题
        int n = nums.size();
        for(int i = 0; i < n; ) // 固定第一个数
        {
            // 利用三数之和解法
            for(int j = i + 1; j < n; )// 固定第二个数
            {
                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]});
                        left++, right--;
                        // 去重left 和 right
                        while(left < right && nums[left] == nums[left - 1]) left++;
                        while(left < right && nums[right] == nums[right + 1]) right--;
                    }
                }
                // 去重 j
                j++;
                while(j < n && nums[j] == nums[j - 1]) j++;
            }
            // 去重 i
            i++;
            while(i < n && nums[i] == nums[i - 1]) i++;
        }
        return ret;
    }
};
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南风与鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值