Codeforces 573B Bear and Blocks

http://codeforces.com/problemset/problem/573/B

 题目大意：

给出n个连续塔，每个塔有高度hi,每次取走最外层的块，问需要多少次操作能够拿光所有的块。

思路:考虑第一次取得时候

h[i]=min(h[i-1],h[i]-1,h[i+1])

那么取k次的时候:

h[i]=max(0,min(h[i-j]-(k-j),h[i+j]-(k-j)))

即

h[i]=max(0,min(h[i-j]+j-k,h[i+j]+j-k))

k为常数，可以先暂时忽略，那就是要求h[i-j]+j和h[i+j]+j的最小值。

然后两遍左右for一下，同时给区间加一

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<iostream>
 struct segtree{
     int l,r,mn,tag;
 }t[];
 int h[],n,l[],r[];
 int read(){
     int t=,f=;char ch=getchar();
     while (ch<''||ch>''){if (ch=='-') f=-;ch=getchar();}
     while (''<=ch&&ch<=''){t=t*+ch-'';ch=getchar();}
     return t*f;
 }
 void pushdown(int k,int l,int r){
     if (l==r||t[k].tag==){
         return;
     }
     t[k*].tag+=t[k].tag;
     t[k*].mn+=t[k].tag;
     t[k*+].tag+=t[k].tag;
     t[k*+].mn+=t[k].tag;
     t[k].tag=;
 }
 void updata(int k,int l,int r){
     if (l==r) return;
     t[k].mn=std::min(t[k*].mn,t[k*+].mn);
 }
 void build(int k,int l,int r){
     t[k].mn=;
     t[k].tag=;
     if (l==r){
         t[k].mn=h[l];
         return;
     }
     int mid=(l+r)>>;
     build(k*,l,mid);
     build(k*+,mid+,r);
     updata(k,l,r);
 }
 void add(int k,int l,int r,int x,int y){
     pushdown(k,l,r);
     if (l==x&&r==y){
         t[k].mn++;
         t[k].tag++;
         pushdown(k,l,r);
         return;
     }
     int mid=(l+r)>>;
     if (y<=mid) add(k*,l,mid,x,y);
     else
     if (x>mid) add(k*+,mid+,r,x,y);
     else add(k*,l,mid,x,mid),add(k*+,mid+,r,mid+,y);
     updata(k,l,r);
 }
 int query(int k,int l,int r,int x,int y){
     pushdown(k,l,r);
     if (l==x&&r==y) return t[k].mn;
     int mid=(l+r)>>;
     if (y<=mid) return query(k*,l,mid,x,y);
     else
     if (x>mid) return query(k*+,mid+,r,x,y);
     else return std::min(query(k*,l,mid,x,mid),query(k*+,mid+,r,mid+,y));
 }
 int main(){
     n=read();
     for (int i=;i<=n;i++) h[i]=read();
     h[]=h[n+]=;
     build(,,n+);
     for (int i=;i<=n;i++){
         add(,,n+,,i-);
         l[i]=query(,,n+,,i);
     }
     build(,,n+);
     for (int i=n;i>=;i--){
         add(,,n+,i+,n+);
         r[i]=query(,,n+,i,n+);
     }
     int ans=;
     for (int i=;i<=n;i++)
      ans=std::max(ans,std::min(l[i],r[i]));
     printf("%d\n",ans);
     return ;
 }

换种思路:我们的每一个竖列，要嘛在旁边两列消掉以后，一次性消掉，或者是一个一个地消

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<iostream>
 int n,vis[];
 int read(){
     int t=,f=;char ch=getchar();
     while (ch<''||ch>''){if (ch=='-') f=-;ch=getchar();}
     while (''<=ch&&ch<=''){t=t*+ch-'';ch=getchar();}
     return t*f;
 }
 int main(){
     n=read();
     for (int i=;i<=n;i++) vis[i]=read();
     vis[]=;
     for (int i=;i<=n;i++) vis[i]=std::min(vis[i],vis[i-]+);
     vis[n]=;
     for (int i=n-;i>=;i--) vis[i]=std::min(vis[i],vis[i+]+);
     int ans=;
     for (int i=;i<=n;i++) ans=std::max(ans,vis[i]);
     printf("%d\n",ans);
     return ;
 }