商品折扣后的最终价格
需要对每个数，找到在这个数后面出现的小于等于它的第一个数，比如第一个数 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;
}
};安排邮筒?
?
?
?
?
