优选算法——双指针2

题目一——有效三角形的个数

思路 

先审题

举个例子，下面一个序列可分成4个三元组

然后我们论证哪个可以组成三角形即可

判断三个数能不能组成三角形：任意两边之和大于第三边

注意第一个和第四个，有人说，这不是两个相同的吗？但是事实上这两组的2不是原序列同一个位置上的二，所以算两个三角形，所以结果就是3

我们知道啊，三角形的判断方法是任意两边之和大于第三边 

但是这个需要判断三次，如果我们知道三者的大小关系，我们只需判断一次即可

解法⼀（暴⼒求解）（会超时）：

算法思路： 三层 for 循环枚举出所有的三元组，并且判断是否能构成三⻆形。

虽然说是暴⼒求解，但是还是想优化⼀下： 判断三⻆形的优化：

• 如果能构成三⻆形，需要满⾜任意两边之和要⼤于第三边。但是实际上只需让较⼩的两条边 之和⼤于第三边即可。
• 因此我们可以先将原数组排序，然后从⼩到⼤枚举三元组，⼀⽅⾯省去枚举的数量，另⼀⽅ ⾯⽅便判断是否能构成三⻆形。 

每层元素控制一个元素 

class Solution {
 public:
    int triangleNumber(vector<int>& nums) {
        // 1. 排序
 
        sort(nums.begin(), nums.end());
        int n = nums.size(), ret = 0;
        // 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;
    }
 };

解法⼆（排序+双指针）：

算法思路： 先将数组排序。

根据「解法⼀」中的优化思想，我们可以固定⼀个「最⻓边」，然后在⽐这条边⼩的有序数组中找 出⼀个⼆元组，使这个⼆元组之和⼤于这个最⻓边。

由于数组是有序的，我们可以利⽤「对撞指针」来优化。

设最⻓边枚举到 i 位置，区间 [left, right] 是 i 位置左边的区间（也就是⽐它⼩的区 间）：

1. 如果 nums[left] + nums[right] > nums[i] ：

• 说明 [left, right - 1] 区间上的所有元素均可以与 nums[right] 构成⽐nums[i] ⼤的⼆元组
• 满⾜条件的有 right - left 种 ▪ 此时 right 位置的元素的所有情况相当于全部考虑完毕， right-- ，进⼊下⼀轮判断

2.如果 nums[left] + nums[right] <= nums[i] ：

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

 

我们再看个完整的例子

代码

class Solution 
{
 public:
    int triangleNumber(vector<int>& nums) 
    {
        // 1. 优化
        sort(nums.begin(), nums.end());
        
        // 2. 利⽤双指针解决问题
        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;
    }
 };

题目二——LCR 179. 查找总价格为目标值的两个商品

注意是有序的 

解法⼀（暴⼒解法，会超时）：

算法思路： 两层 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++) { // 第⼀层循环从前往后列举第⼀个数


                for (int j = i + 1; j < n; j++) { // 第⼆层循环从i位置之后列举第⼆个数
                    if (nums[i] + nums[j] == target) // 两个数的和等于⽬标值，说明我们已经找到结果了
                        return { nums[i], nums[j] };
                }
            }
            return { -1, -1 };
        }


    };

 解法⼆（双指针-对撞指针）：

算法思路： 注意到本题是升序的数组，因此可以⽤「对撞指针」优化时间复杂度。

 算法流程（附带算法分析，为什么可以使⽤对撞指针）：

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>& nums, int target)
    {
        int left = 0, right = nums.size() - 1;
        while (left < right)
        {
            int sum = nums[left] + nums[right];
            if (sum > target) right--;
            else if (sum < target) left++;
            else return { nums[left], nums[right] };
        }
        // 照顾编译器

            return { -4941, -1 };
    }
};

题目三——三数之和

审题

上面有重复元素的一组

解法一：暴力枚举+去重

 解法二：（排序+双指针）：

 代码

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; ) //  固定数 a
        {
            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;
    }
};

 题目四——四数之和

解法（排序+双指针）

这题和三数之和的核心思想是一模一样的，解法我们直接照搬三数之和

算法思路：

1. 依次固定⼀个数 a ；
2. 在这个数 a 的后⾯区间上，利⽤「三数之和」找到三个数，使这三个数的和等于 target - a 即可。

我们可以依次固定两个数a,b，再用快慢指针去找 

代码

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; ) // 固定数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) 
                        left++;
                    else if (sum > aim) 
                        right--;
                    else
                    {
                        ret.push_back({nums[i], nums[j], nums[left++],
                            nums[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;
    }
};