商品折扣后的最终价格
需要对每个数,找到在这个数后面出现的小于等于它的第一个数,比如第一个数 8,会在后面找到第一个小于等于 8 的数 4,第二个数 4,会在后面找到第一个小于等于 4 的数 2. . . 如果某个数能在找到一个小于等于它的数,就在后面减去这个数,然后输出,8 找到的数是 4,输出 8 - 4 = 4,6 找到的数是 2,输出 6 - 2 = 4,2 没有找到比它小的数,输出 2
数据范围:500,时间复杂度可以控制在 O( n^2),直接按题目要求暴搜
class Solution {
public:
vector<int> finalPrices(vector<int>& prices) {
for(int i = 0; i < prices.size(); i++) {
for(int j = i + 1; j < prices.size(); j++) {
if(prices[i] >= prices[j]) {
prices[i] -= prices[j];
break;
}
}
}
return prices;
}
};
找离它最近的比它小的数
用单调栈,每一个数只会进栈一次出栈一次,时间复杂度为 O( n )
链表与邻接表、栈与队列、单调栈、单调队列、kmp 算法_菜徐鸭的博客-CSDN博客
暴力求解:从后往前做,每个数找的是它后面的数
把每一个数存储到栈中:8 4 6 2 3
优化思路:看一下栈里面哪些元素没有意义,比如 2 和 3,其中 3 一定不会作为答案输出,由于 2 是小于 3 的,如果 3 可以作为答案输出的话(由于 3 小于等于当前数,那么 2 一定小于等于当前数 ),2 将会是比 3 更好的选择( 2 离目标数更近,只要 2 存在,3 就一定不会被用到 )
只要前一个数 a[ i ] ≤ 后一个数 a[ i + 1],后一个数 a[ i + 1] 就一定不会被使用,一定可以把 a[ i + 1] 删掉,把栈里面所有没有用的数删除后,意味着所有相邻两个数之间一定有 a[ i ] > a[ i + 1],就会变成当前栈
当前有一个数过来了,先在栈中找一下有没有数比它小或者相等,从栈顶开始找,如果栈顶元素比当前元素大的话,就满足 a[ i ] ≤ a[ i + 1] 的关系,栈顶元素就一定没有用,就需要把栈顶元素删除,查询到栈顶元素和当前元素相等为止,查询后,相等的元素也是没有意义的,再继续删除,直到删到第一个比它小为止,然后把这个数加入到栈里面
class Solution {
public:
vector<int> finalPrices(vector<int>& prices) {
//定义答案数组
vector<int> res;
//定义单调栈
stack<int> stk;
//从后往前枚举
for(int i = prices.size() - 1;i >= 0;i--) {
//取出当前这个数
int t = prices[i];
//当栈里面有元素的时候 并且栈顶元素的值大于当前数 就删除栈顶元素
while(stk.size() && stk.top() > t) stk.pop();
//如果栈里面有元素
if(stk.size()) res.push_back(t - stk.top());
//如果栈里面没有元素 不能打折 就是原数
else res.push_back(t);
//把所有和当前数相等的栈顶元素删除
while(stk.size() && stk.top() == t) stk.pop();
//把当前数加到栈里面
stk.push(t);
}
//输出前翻转答案数组
return vector<int>(res.rbegin(),res.rend());
}
};
#include<iostream>
using namespace std;
#include<stack>
#include<vector>
int main()
{
vector<int> prices;
prices.push_back(8);
prices.push_back(4);
prices.push_back(6);
prices.push_back(2);
prices.push_back(3);
vector<int> res;
stack<int> stk;
for (int i = prices.size() - 1; i >= 0; i--) {
int t = prices[i];
cout << "t:" << t << endl;
while (stk.size() && stk.top() > t) {
cout << "删除栈顶元素top():" << stk.top()<<endl; stk.pop();
};
if (stk.size()) {
cout << "插入t - stk.top():" << t - stk.top() <<"到结果数组中" << endl; res.push_back(t - stk.top());
}
else {
cout << "插入t:" << t << "到结果数组中" << endl;
res.push_back(t);
}
while (stk.size() && stk.top() == t) {
cout << "删除栈顶元素top():" << stk.top() << endl;
stk.pop();
}
cout << "把数据t:"<< t <<"插入到栈中"<<endl;
stk.push(t);
}
cout << "-----打印结果数组-----" << endl;
for (auto v : res)
{
cout << v << "\t ";
}
cout << endl;
cout << "-----打印栈中数据-----" << endl;
while (!stk.empty()) //判断当前栈是否为空
{
cout << stk.top() << "\t"; //获取栈顶元素
stk.pop(); //不断出栈
}
}
/* 输出 */
t:3
插入t:3到结果数组中
把数据t:3插入到栈中
t:2
删除栈顶元素top():3
插入t:2到结果数组中
把数据t:2插入到栈中
t:6
插入t - stk.top():4到结果数组中
把数据t:6插入到栈中
t:4
删除栈顶元素top():6
插入t - stk.top():2到结果数组中
把数据t:4插入到栈中
t:8
插入t - stk.top():4到结果数组中
把数据t:8插入到栈中
-----打印结果数组-----
3 2 4 2 4
-----打印栈中数据-----
8 4 2
注意栈顶一直在变化
#include<iostream>
using namespace std;
#include<stack>
#include<vector>
int main()
{
stack<int> prices;
prices.push(8);
cout << prices.top() << endl;
prices.push(4);
cout << prices.top() << endl;
prices.push(6);
cout << prices.top() << endl;
prices.push(2);
cout << prices.top() << endl;
prices.push(3);
cout << prices.top() << endl;
}
/* 输出 */
8
4
6
2
3
子矩形查询
要求实现一个类,这个类是用来维护一个矩阵,一开始告诉我们这个矩阵是什么,需要实现两种操作:①把某一个子矩阵里面的值全部变成一个新的数 newValue→ 直接遍历子矩阵,把这个子矩阵的值改变 ②查询矩阵中的某一个元素的值是多少
数据范围较小,直接暴力写即可,第一个操作时间复杂度是最大是整个矩阵的元素个数,第二个操作的时间复杂度是 O( 1 ),最坏时间复杂度为 O(500w)
class SubrectangleQueries {
public:
//存储矩阵
vector<vector<int>> q;
SubrectangleQueries(vector<vector<int>>& rectangle) {
q = rectangle;
}
//更新操作直接遍历子矩阵
void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
//改变矩阵中的每一个数
for(int i = row1;i <= row2;i++ )
for(int j = col1;j <= col2;j++ )
q[i][j] = newValue;
}
int getValue(int row, int col) {
return q[row][col];
}
};
/**
* Your SubrectangleQueries object will be instantiated and called as such:
* SubrectangleQueries* obj = new SubrectangleQueries(rectangle);
* obj->updateSubrectangle(row1,col1,row2,col2,newValue);
* int param_2 = obj->getValue(row,col);
*/
找两个和为目标值且不重叠的子数组
给出一个数组,让我们找到两个互不重叠的子数组,使得它们的和都等于 target,如果有多个方案,要返回所有方案里面两个子数组长度之和的最小值
注意:子数组是连续的子数组,指的是区间,不是子序列
就是给出一个数组,要在里面找到不相交的两段,使得每段的和都是 target,并且要求这两段的长度之和最小,输出最小长度之和
数据范围:10^5,比较大,时间复杂度要控制在 O( nlogn ) 或者 O( n )
数值都是正数,当区间的某一个端点固定的时候,另一个端点离它越远,区间的长度越大
先考虑如果只要求一段,使得和是 target,并且区间长度最小应该怎么求?
双指针算法:双指针算法、位运算、离散化、区间合并_小雪菜本菜的博客-CSDN博客
对于每一个 i 要找到一个最远的 j,使得从第 j 个数加到第 i 个数的和是小于等于 target
当 i 往后走(i 移到 i ' 的时候),从 j 到 i ' 的和一定是大于从 j 到 i 的和,由于每一个数都是正的
所以 i ' 对应的 j,要么在 j 的位置,要么在 j 的后面,不可能在 j 的前面
反证法:
如果 i ' 对应的值 j ' 在 j 前面,说明 j ' 到 i ' 是小于等于 target,那么从 j ' 到 i 也是小于等于 target(某一个子集的和也应该满足要求),就与 j 是离 i 最远的 j 就矛盾了
当 i 往后走的时候,j 也一定要往后走
每次把 i 往后移动一格,不断向后调整 j 的位置,直到从 i 加到 j 小于等于 target 为止,最后两个指针分别会走 n 步,两个指针一共会走 2n 步,时间复杂度为 O( n )
如果有两个区间要怎么处理,加一个记忆化,可以枚举一下后面那个区间:( 刚刚求的是小于等于 target 最远的一个 j,求完之后只要判断从 j 加到 i 是不是恰好等于 target 就知道这一段是不是合法的)比如说对于当前的 i 找到一个 j,使得 j 加到 i 恰好等于 target,要在 j 前面找到一段,使得这一段的总和是 target,并且总长度最小
用 f[ i ] 表示从 0 - i 的所有子区间里面和等于 target 的长度的最小值,i - j + 1 + f[ j -1 ] 就是两段的最小值
f[ i ] 的更新有两种情况:以 i 结尾(i - j + 1),不以 i 结尾,相当于 1 - i 中不包含 i(以 i - 1 结尾),f[ i - 1 ] 就是1 - i-1 中的最小值,两种情况取最小值即可
第一遍扫描的时候,边扫描边记录一个 f 数组,找到第一段之后,在第一段的前面 j - 1 的位置开始,相当于在 1 - j-1 里面找到一个最短的,就是 f[j - 1]
class Solution {
public:
int minSumOfLengths(vector<int>& arr, int target) {
int n = arr.size();
vector<int> f(n,1e8);
//答案
int res = INT_MAX;
for(int i = 0,j = 0,sum = 0;i < n;i++ ) {
//把和加上当前的值
sum += arr[i];
while(sum > target) sum-= arr[j++ ];
if(sum == target) {
//j 必须要大于0 因为要有两段不能只有一段-> 当前这段长度加上前一段的最少长度
if(j) res = min(res,i - j + 1 + f[j -1]);
//f[i] 等于当前这种情况
f[i] = i - j + 1;
}
//如果 i 不为0 就更新
if(i) f[i] = min(f[i],f[i - 1]);
}
//无解
if(res > arr.size()) res = -1;
return res;
}
};
安排邮筒