程序设计思维与实践 Week5 作业（最大矩形、TT's Magic Cat、平衡字符串、滑动窗口）

**

A - 最大矩形

**
题目描述
给一个直方图，求直方图中的最大矩形的面积。例如，下面这个图片中直方图的高度从左到右分别是2, 1, 4, 5, 1, 3, 3, 他们的宽都是1，其中最大的矩形是阴影部分。
Input
输入包含多组数据。每组数据用一个整数n来表示直方图中小矩形的个数，你可以假定1 <= n <= 100000.
然后接下来n个整数h1, …, hn, 满足 0 <= hi <= 1000000000.
这些数字表示直方图中从左到右每个小矩形的高度，每个小矩形的宽度为1。 测试数据以0结尾。

Output
对于每组测试数据输出一行一个整数表示答案。

Sample Input

7 2 1 4 5 1 3 3
4 1000 1000 1000 1000
0

Sample Output

8
4000

解题思路
利用单调栈求解。求矩形的最大面积，在确定矩形高度之后，左端点越靠左、右端点越靠右，矩形的面积就越大。两边单调栈处理出以每个点为高时的左右端点，其中左端点为往左数第一个小于此高度的点，右端点为往右数第一个小于此高度的点。

端点的寻找：以右端点为例。定义一个栈，从左往右遍历数组a，如果当前的元素大于栈顶元素，就将该元素对应a数组中的索引压入栈中；如果小于栈顶元素，就循环弹出栈顶元素，直到当前的栈顶元素小于要入栈的元素。在循环中，对于每一个要弹出的元素来说，当前即将入栈的元素都是右边第一个小于自己的元素，所以在弹出之前，将其在r数组中对应的值赋值为当前入栈元素的索引减一。遍历完a中所有元素之后，如果栈非空，就将栈中元素对应的r均赋值为最后一个索引。（入栈的元素以及r数组中存储的值均为索引值，比较的是a数组中的元素值）

经过两边单调栈处理可以得到两个数组，一个r，一个l，分别存储a中每一个元素向右向左延伸的最远位置，经过循环计算矩形面积输出最大值即可。

注意
题目中的a[i]范围是10的九次方，经过面积计算会超出int的范围，所以要将数据以long long存储，否则会WA。

C++代码

#include<iostream>
#include<stack>
using namespace std;
stack<int> q;
void search_r(long long *a,int *r,int n)
{
 for(int i=0;i<n;i++)
 {
  while(!q.empty()&&a[i]<a[q.top()])
  {
   r[q.top()]=i-1;
   q.pop();
  }
  q.push(i);
 }
 while(!q.empty())
 {
  r[q.top()]=n-1;
  q.pop();
 }
 return;
}
void search_l(long long *a,int *l,int n)
{
 for(int i=n-1;i>=0;i--)
 {
  while(!q.empty()&&a[i]<a[q.top()])
  {
   l[q.top()]=i+1;
   q.pop();
  }
  q.push(i);
 }
 while(!q.empty())
 {
  l[q.top()]=0;
  q.pop();
 }
 return;
}
int main()
{
 int n=0;
 while(true)
 {
  cin>>n;
  if(n==0) return 0;
  long long *a=new long long[n];
  int *l=new int[n];
  int *r=new int[n];
  for(int i=0;i<n;i++)
  {
   cin>>a[i];
  } 
  long long max=0;
  search_r(a,r,n);
  search_l(a,l,n);
  for(int i=0;i<n;i++)
  {
   if(max<(r[i]-l[i]+1)*a[i]) max=(r[i]-l[i]+1)*a[i];
  }
  cout<<max<<endl;
  delete [] a;
  delete [] l;
  delete [] r;
 }
 return 0;
}

**

B - TT’s Magic Cat

**
题目描述
在世界地图中寻找n个城市，a[i]表示每个城市的价值，每一轮选择[l,r]区间上的一个城市，令其价值减c，请给出减少q轮之后每个城市的价值。

Input
第一行输入两个整数n,q(1≤n,q≤2⋅105)，分别表示城市的个数和减少的轮数。
第二行输入n个整数，为a数组赋值： a1,a2,…,an (−106≤ai≤106)。
接下来输入q行数据，每一行表示每一轮的相关数据：l、r、c (1≤l≤r≤n,−105≤c≤105)

Output
每一行输出n个数据，表示n个城市对应的价值。

Examples
Input

4 2
-3 6 8 4
4 4 -2
3 3 1

Output

-3 6 9 2

Input

2 1
5 -2
1 2 4

Output

9 2

Input

1 2
0
1 1 -8
1 1 -6

Output

-14

解题思路
该题如果直接循环进行每次的更新，时间复杂度太高，会超时，所以采用前缀和与差分来进行处理。将原数组转变为差分数组，将区间修改转变为单点修改。

定义一个数组b存放a数组中每一个元素与前一个元素的差值（首元素直接为首元素），每一次循环只修改左右端点处的差值，b[l]=b[l]+c，b[r+1]=b[r+1]-c。循环修改完成后再更新一次a数组的值即可。

C++代码

#include<iostream>
using namespace std;
int main()
{
 int n=0,q=0;
 cin>>n>>q;
 long long *a=new long long[n];
 long long *b=new long long[n];
 for(int i=0;i<n;i++)
 {
  cin>>a[i];
 }
 b[0]=a[0];
 for(int i=1;i<n;i++)
 {
  b[i]=a[i]-a[i-1];
 }
 for(int i=0;i<q;i++)
 {
  int l=0,r=0;
  long long c=0;
  cin>>l>>r>>c;
  b[l-1]=b[l-1]+c;
  if(r-1!=n-1) b[r]=b[r]-c; 
 }
 a[0]=b[0];
 cout<<a[0];
 for(int i=1;i<n;i++)
 {
  a[i]=a[i-1]+b[i];
  cout<<" "<<a[i];
 }
 return 0;
}

**

C - 平衡字符串

**
题目描述
一个长度为 n 的字符串 s，其中仅包含 ‘Q’, ‘W’, ‘E’, ‘R’ 四种字符。
如果四种字符在字符串中出现次数均为 n/4，则其为一个平衡字符串。
现可以将 s 中连续的一段子串替换成相同长度的只包含那四个字符的任意字符串，使其变为一个平衡字符串，问替换子串的最小长度?
如果 s 已经平衡则输出0。

Input
一行字符表示给定的字符串s

Output
一个整数表示答案

Examples
Input

QWER

Output

0

Input

QQWE

Output

1

Input

QQQW

Output

2

Input

QQQQ

Output

3

注意
1<=n<=10^5
n是4的倍数
字符串中仅包含字符 ‘Q’, ‘W’, ‘E’ 和 ‘R’.

解题思路
本题所求答案为一个连续区间，区间左右端点移动有明确方向：当前[L,R]满足要求，则L++;不满足要求，则R++。因此可以采用尺取法求解。对于给定的区间[L,R]，对不包含在区间[L,R]中的字符串中各个字母出现的次数m[‘Q’]、m[‘W’]、m[‘E’]、m[‘R’]，进行判断。令maxx为四个次数中的最大值，total为当前区间长度，free=total-((maxx-m[‘Q’])+(maxx-m[‘W’])+(maxx-m[‘E’])+(maxx-m[‘R’]))。

如果free>=0且为4的倍数，则满足要求，表示需要修改的字符已经包含在了区间内，接下来缩小区间继续进行判断，L++；否则，表示区间外还存在需要修改的字符，就扩大区间，令R++。每一次判断满足条件时要将当前的区间长度与ans进行比较，将较小值赋值给ans，当循环到R至最后一个元素时，循环结束，输出结果即可。

在循环过程中，每一次进行区间的扩大与缩小时，都需要进行各个字符个数的更新。

C++代码

#include<iostream>
#include<string>
#include<algorithm>
#include<map>
using namespace std;
map<char,int> m;
int main()
{
 m['Q']=0,m['W']=0,m['E']=0,m['R']=0;
 string str;
 cin>>str;
 int n=str.length();
 for(int i=0;i<n;i++)
 {
  m[str[i]]++;
 }
 if(m['Q']==m['W']&&m['Q']==m['E']&&m['Q']==m['R'])
 {
  cout<<"0"<<endl;
  return 0;
 }
 int l=0,r=0,maxx=0,total=1,free=0,ans=100001;
 m[str[0]]--;
 while(true)
 {
  maxx=max(max(m['Q'],m['W']),max(m['E'],m['R']));
  total=r-l+1;
  free=total-((maxx-m['Q'])+(maxx-m['W'])+(maxx-m['E'])+(maxx-m['R']));
  if(free>=0&&free%4==0)
  {
   ans=min(ans,total);
   m[str[l]]++;
   l++;
  }
  else
  {
   if(r<n-1) r++;
   else break;
   m[str[r]]--;
  }
 }
 cout<<ans<<endl;
 return 0;
}

**

D - 滑动窗口

**
题目描述
ZJM 有一个长度为 n 的数列和一个大小为 k 的窗口, 窗口可以在数列上来回移动. 现在 ZJM 想知道在窗口从左往右滑的时候，每次窗口内数的最大值和最小值分别是多少.
例如：
数列是[1 3 -1 -3 5 3 6 7], 其中k 等于 3.

Window position	Minimum value	Maximum value
[1 3 -1] -3 5 3 6 7	-1	3
1 [3 -1 -3] 5 3 6 7	-3	3
1 3 [-1 -3 5] 3 6 7	-3	5
1 3 -1 [-3 5 3] 6 7	-3	5
1 3 -1 -3 [5 3 6] 7	3	6
1 3 -1 -3 5 [3 6 7]	3	7

Input
输入有两行。第一行两个整数n和k分别表示数列的长度和滑动窗口的大小，1<=k<=n<=1000000。第二行有n个整数表示ZJM的数列。

Output
输出有两行。第一行输出滑动窗口在从左到右的每个位置时，滑动窗口中的最小值。第二行是最大值。

Sample Input

8 3
1 3 -1 -3 5 3 6 7

Sample Output

-1 -3 -3 -3 3 3
3 3 5 5 6 7

解题思路
如果查找全局的最值，可以使用单调栈，但现在要求查找窗口内的最值，是一个局部的概念，所以可以维护一个单调队列，队列中的元素均属于当前窗口，当元素不属于当前窗口时，将队首元素弹出即可。如果是单调递减队列，则队首元素即为当前窗口的最大值；如果是单调递增队列，则队首元素即为当前窗口的最小值。

单调队列的实现过程与单调栈相似，只是加上了对单调队列长度的维护，如果当前队首与队尾的长度（队列存的是索引）大于了k，就将队首元素删除。

提交时的错
提交代码时出现了超时，于是将代码中的输入输出流改为标准输入输出：scanf、printf就好了。

C++代码

#include<deque>
#include<cstdio>
using namespace std;
int main()
{
 deque<int> q;
 int n=0,k=0;
 scanf("%d %d",&n,&k);
 int *a=new int[n];
 for(int i=0;i<n;i++)
 {
  scanf("%d",&a[i]);
 }
 for(int i=0;i<n;i++)//找最小值 
 {
  while(!q.empty()&&a[i]<a[q.back()])
  {
   q.pop_back();
  }
  q.push_back(i);
  if(q.back()-q.front()+1>k) q.pop_front();
  if(i-k+1>=0) 
  {
   if(i-k+1==0) printf("%d",a[q.front()]);
   else printf(" %d",a[q.front()]);
  }
 }
 printf("\n");
 q.clear();
 for(int i=0;i<n;i++)//找最大值 
 {
  while(!q.empty()&&a[i]>a[q.back()])
  {
   q.pop_back();
  }
  q.push_back(i);
  if(q.back()-q.front()+1>k) q.pop_front();
  if(i-k+1>=0) 
  {
   if(i-k+1==0) printf("%d",a[q.front()]);
   else printf(" %d",a[q.front()]);
  }
 }
 printf("\n");
 return 0;
}