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

思路 

先审题

举个例子，下面一个序列可分成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和 rightwhile (left < right && nums[left] == nums[left - 1]) left++;while (left < right && nums[right] == nums[right + 1])right--;}}// 去重ii++;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;}
};