week5 A
题意
思路
对每一个矩形，将其序号以及高度压入到单调递增栈中，找到每个序号的矩形右边第一个小于它的位置，然后将序号反序压入单调递增栈中，找到左边第一个小于它的位置，将两个位置相减乘以该矩形高度即可得到一个最大矩形
总结
维护一个单调栈，当一个元素入栈时，判断入栈之后会不会破坏栈的单调性，如果新元素入栈会波坏单调性，则将栈顶元素弹出，直到满足单调性，并且将新元素入栈，通过这个特点可以找到在一个序列中任意数往左/往右找比它大（单调递增栈）/小（单调递减栈）的元素，可以求得以当前元素为最大值的最大区间
代码
#include <stack>
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
struct rect{
long long h;//矩形高度
int i;//第i个矩形
rect(){}
rect(long long _h,int _i){
h = _h;
i = _i;
}
};
rect test[100000];
int l[100000];//左边的区间
int r[100000];//右边的区间
long long ans;
long long n;
stack<rect> s;
int main()
{
while (cin>>n)
{
ans = 0;
if(n == 0) break;
for (int i = 0; i < n; i++)
{
cin>>test[i].h;
test[i].i = i;
}
//搜索右边第一个小于test[i].h的矩形
for (int i = 0; i < n; i++)
{
while (s.size() > 0 && s.top().h > test[i].h)
{
rect temp = s.top();
s.pop();
r[temp.i] = i;
}
s.push(test[i]);
}
while (!s.empty())
{//在栈中的矩形的右端点为n
rect temp = s.top();
s.pop();
r[temp.i] = n;
}
//搜索左边第一个小于test[i].h的矩形 不需要存一个反向数组
//将i从n反向遍历就行
for (int i = n-1; i >= 0; i--)
{
while (s.size()>0 && s.top().h > test[i].h)
{
rect temp = s.top();
s.pop();
l[temp.i] = i;
}
s.push(test[i]);
}
while (!s.empty())
{//在栈中的元素的左端点设为-1
rect temp = s.top();
s.pop();
l[temp.i] = -1;
}
for (int i = 0; i < n; i++)
{
if (ans < (test[i].h * (r[i] - l[i] -1)))
{
ans = (test[i].h * (r[i] - l[i] -1));
}
}
cout<<ans<<endl;
}
return 0;
}
week5 B
题意
思路
初始化数组A与B，关系为B[i] = A[i] - A[i - 1],这样B数组的前缀和就能成为A数组的元素值：sum{B[1 ~ i]} = A [i]，A数组对某一个区间操作就可以化为对B数组的单点修改A[L] ~ A[R] + c = B[L] + c,B[R+1] -C
总结
运用差分与前缀，在O(1)的复杂度下可以求出一个区域内所有元素的数值之和，当问题涉及到快速求取某一区域的和的时候，就可以运用前缀计算
代码
#include <iostream>
#include <cstdio>
using namespace std;
long long n;
long long q;
//改大点
long long a[1000000];
long long b[1000000];
int main()
{
std::ios::sync_with_stdio(false);
cin>>n>>q;
for (int i = 1; i < (n + 1); i++)
{
cin>>a[i];
}
//构造差分数列b
a[0] = 0;
for (int i = 1; i < (n + 1); i++)
{
b[i] = a[i] - a[i - 1];
}
for (int i = 0; i < q; i++)
{
long long l,r,f;
cin>>l>>r>>f;
b[l] = b[l] + f;
b[r + 1] = b[r + 1] - f;
}
long long sum = 0;
for (int i = 1; i < (n+1); i++)
{
sum = sum + b[i];
cout<<sum<<" ";
}
return 0;
}
week5 C
题意
思路
用两个伪指针来维护一个区间，区间里的空间大小表示可以替换的字符个数，记录下在这个区间外QWER四个字符出现的次数，记录下四个字符个数最大的数MAX，用MAX减去剩下的三个元素出现的个数就能得到要被替换的总元素个数，用区间里的总容量减去替换个数就得到剩余的空间free，如果free能被4整除，那么这个区间的元素被替换后就能让字符串平衡
总结
运用尺取法，维护两个指针L 与 R ，当L与R之间的区间不满足设定的要求之后，移动R指针扩大区间范围答案，如果满足要求的话就移动L指针使区间缩小，尺取法可以运用在求解答案为一个连续区间并且区间左右端点有明确移动方向的题目
代码
#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;
// int sumQ,sumW,sumE,sumR;
int total;//区间内元素个数
int FREE;//剩下的空余元素个数
int MAX;//最大元素个数
int MIN;//最小区间
int a[4];//sumQ,sumW,sumE,sumR;
int findmax()
{
int m = -1;
for (int i = 0 ; i < 4 ; i++)
{
if (m < a[i])
m = a[i];
}
return m;
}
void in(char b)
{
if(b == 'Q') a[0]++;
if(b == 'W') a[1]++;
if(b == 'E') a[2]++;
if(b == 'R') a[3]++;
}
void out(char b)
{
if(b == 'Q') a[0]--;
if(b == 'W') a[1]--;
if(b == 'E') a[2]--;
if(b == 'R') a[3]--;
}
int main()
{
std::ios::sync_with_stdio(false);
string test;
cin>>test;
for (int i = 0; i < test.size(); i++)
{
in(test[i]);
}
//初始化 初始化时判断是否已经是平衡字符串
MIN = 10000000;
int l = 0, r = 0;
bool flag = false;
if (a[0] == test.size()/4 && a[1] == test.size()/4 &&a[2] == test.size()/4 &&a[3] == test.size()/4)
{
flag = true;
MIN = 0;
}
//***********
out(test[0]);
//在lr的区域外找最大的个数
MAX = findmax();
while (!flag &&l <= r && r < test.size() )
{
MAX = findmax();
total = r - l + 1;
FREE = total - (MAX - a[0]) - (MAX - a[1]) - (MAX - a[2]) - (MAX - a[3]);
if (FREE>=0 && FREE % 4 == 0)
{//成功缩短左区间
if(MIN > total) MIN = total;
if(l < test.size()) in(test[l]);//一个元素变成lr外
l++;
}
else
{
r++;
if(r < test.size()) out(test[r]);//一个元素变成lr内
}
}
cout<<MIN;
return 0;
}
// map<string,int> sum;
// int findmax(map<string,int> &sum)
// {
// int m = 0;
// for (map<string,int>::iterator it = sum.begin(); it!=sum.end(); it++)
// {
// if (m< it->second)
// {
// m = it->second;
// }
// }
// return m;
// }
week5 D
题意
思路
将窗口的序列用一个单调递增队列与一个单调递减队列来分别跑一边，选出在K个大小窗口范围内的最小元素以及最大元素，先将队列头中不符合区间的点直接弹出，在队尾加入元素时，将不满足单调性的元素从队尾弹出，用这样的方法来维护一个单调区间，并且在队首的元素一定是最小或者最大的
总结
利用单调队列可以队首出队以及前面的元素一定比后面的元素先入队的性质，使得它可以维护局部的单调性
代码
// #include <stdio.h>
// #include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
int n,k;
struct slide
{
int i;//序号
int value;//值
slide(){}
slide(int _i,int _value)
{
i = _i;
value = _value;
}
}a[1000000];
deque <slide> incrase;
deque <slide> decrase;
void f1()
{
//初始化 前k个
for (int i = 0; i < k-1; i++)
{
while (incrase.size()>0 && a[i].value < incrase.back().value)
{
incrase.pop_back();
}
incrase.push_back(a[i]);
}
int left;
for (int i = k - 1; i < n; i++)
{
left = incrase.front().i;
while (incrase.size()>0 && (i + 1 - left) > k)//去除不在范围内的
{
incrase.pop_front();
left = incrase.front().i;
}
while (incrase.size() > 0 && a[i].value < incrase.back().value)
{
incrase.pop_back();
}
incrase.push_back(a[i]);
cout<<incrase.front().value<<" ";
}
}
void f2()
{
//初始化 前k个
for (int i = 0; i < k - 1;i++)
{
while (decrase.size() > 0 && a[i].value > decrase.back().value)
{
decrase.pop_back();
}
decrase.push_back(a[i]);
}
int left = decrase.front().i;
for (int i = k - 1; i < n; i++)
{
left = decrase.front().i;
while (decrase.size() > 0 && (i + 1 - left) > k)
{
decrase.pop_front();
left = decrase.front().i;
}
while (decrase.size() > 0 && a[i].value > decrase.back().value)
{
decrase.pop_back();
}
decrase.push_back(a[i]);
cout<<decrase.front().value<<" ";
}
}
int main()
{
std::ios::sync_with_stdio(false);
cin>>n>>k;
for (int i = 0; i < n ; i++)
{
a[i].i = i;
cin>>a[i].value;
}
f1();
cout<<endl;
f2();
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
