【每日刷题】Day105
🥕个人主页：开敲🍉
🔥所属专栏：每日刷题🍍
🌼文章目录🌼
[1. 1658. 将 x 减到 0 的最小操作数 - 力扣（LeetCode）](#1. 1658. 将 x 减到 0 的最小操作数 - 力扣（LeetCode）)
[2. 904. 水果成篮 - 力扣（LeetCode）](#2. 904. 水果成篮 - 力扣（LeetCode）)
[3. 34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）](#3. 34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）)
1. 1658. 将 x 减到 0 的最小操作数 - 力扣（LeetCode）
//思路：滑动窗口。
//本题如果按照题目的思路去数组两边寻找数让x能够减为0那么会非常困难，从题目所给的示例就可以看出：有时候我们一直在数组右边找数组，有时候我们一会儿在数组左边找，一会儿在数组右边找，有时候甚至左右都找不到。
//既然如此，我们果断放弃从正面求解的思路，根据 "正难则反" 思想，我们试试从反面如何求解：
class Solution {
public:
int minOperations(vector<int>& nums, int x)
{
//target初始为-x，后续遍历数组直接将target += 数组中的所有元素 就能求出 sum - x
int left = 0,right = 0,target = -x;
for(int i = 0;i<nums.size();i++)
{
target+=nums[i];
}
//因为数组中的值全都是＞0的，因此如果target＜0我们不可能找到一个区间的和等于target，直接返回-1
if(target<0) return -1;
int max = -1;
//后面思路与 Day103 中 "长度最小的子数组" 这道题一样
while(right<nums.size())
{
target-=nums[right++];
while(target<0)
{
target+=nums[left++];
}
if(target==0)
max = max>(right-left)?max:(right-left);
}
if(max==-1) return -1;
else return nums.size()-max;
}
};
2. 904. 水果成篮 - 力扣（LeetCode）
//思路：滑动窗口。
//本题我们依旧是在暴力遍历的基础上进行优化，优化的最终结果就是滑动窗口。
//先来看看暴力解法的思路：
//下面来进行优化：
//从上面暴力遍历我们仔细思考可以发现，当我们第一轮遍历结束后是让left++。但是left++还是到3的位置，因此right还是会在2的位置停下来。
//再下一轮left++还是指向3，right还是会在2的位置停下来。
//优化：我们可以在一轮结束后，不让left++，而是让left直接跳过相同的元素：
//但是，光有上面的优化本题的速度还是很慢，那我们还可以怎么优化呢？
class Solution {
public:
int totalFruit(vector<int>& fruits)
{
int ans = 0,j = 0,i = 0;
for(;i<fruits.size();)
{
//stack代表两个篮子
int stack[2] = {-1,-1};
int num = 0,j = i;
while(j<fruits.size())
{
//情况一
if(num==0||(num>0&&num<2&&fruits[j]!=stack[num-1])) stack[num++] = fruits[j++];
//情况二
else if (fruits[j]==stack[0]||fruits[j]==stack[1]) j++;
//情况三
else
{
ans = ans>(j-i)?ans:(j-i);
break;
}
ans = ans>(j-i)?ans:(j-i);
}
//优化一：跳过相同数字
i++;
while(i<fruits.size()&&fruits[i]==fruits[i-1])
{
i++;
}
//优化二：判断数组剩余长度
if(ans>fruits.size()-i) break;
}
ans = ans>(j-i)?ans:(j-i);
return ans;
}
};
3. 34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）
//解法一：朴素二分查找+双向暴力遍历。(可以解决问题，但不符合题意，O(N))
//首先二分查找将mid定位到等于target值的位置
//定位好后让left和right都指向mid，向两边遍历。
//left遍历：当left＞0并且left == target，left向前找target第一次出现的位置
//right遍历，当right+1＜数组长度并且right == target，right向后找target最后一次出现的位置
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target)
{
vector<int> ans = {-1,-1};
int left = 0;
int right = nums.size()-1;
while(left<=right)
{
//二分查找
int mid = left+(right-left)/2;
if(nums[mid]<target) left = mid+1;
else if(nums[mid]>target) right = mid-1;
//当mid定位到与target相同的值时，left和right都指向mid，开始向两边查找
else
{
left = right = mid;
while(left>0&&nums[left]==target&&nums[left-1]==nums[left])
{
left--;
}
while(right+1<nums.size()&&nums[right]==target&&nums[right]==nums[right+1])
{
right++;
}
ans[0] = left;
ans[1] = right;
break;
}
}
return ans;
}
};
//解法二：二段性二分查找
//朴素的二分查找我们只能在有序数组中查找某一个数。但是本题显然是让我们查找某个数出现的区间，也就是这个数第一次和最后一次出现的位置，那么使用朴素的二分查找显然是没法解决问题的。
//这里我们利用单调数组的二段性来解决这个问题，什么是二段性？
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target)
{
vector<int> ans = {-1,-1};
if(!nums.size()) return ans;
int left = 0;
int right = nums.size()-1;
while(left<right)//查找左端点
{
int mid = left+(right-left)/2;
//情况①
if(nums[mid]<target) left = mid+1;
//情况②
else right = mid;
}
//这里需要判断一下是否找到了target
if(nums[left]==target) ans[0] = left;
else return ans;
right = nums.size()-1;
while(left<right)//查找右端点
{
int mid = left+(right-left+1)/2;
//情况①
if(nums[mid]>target) right = mid-1;
//情况②
else left = mid;
}
if(nums[right]==target)
ans[1] = right;
return ans;
}
};