题目一——有效三角形的个数
思路
先审题
举个例子，下面一个序列可分成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;
}
};题目四——四数之和
解法（排序+双指针）
这题和三数之和的核心思想是一模一样的，解法我们直接照搬三数之和
算法思路：
- 依次固定⼀个数 a ；
- 在这个数 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;
}
};
