扶桑号战列舰 （单调栈+线段树区间更新懒惰标记 or 栈）

传送门

•题目描述

题目描述
众所周知，一战过后，在世界列强建造超无畏级战列舰的竞争之中，旧日本海军根据“个舰优越主义”，建造了扶桑级战列舰，完工时为当时世界上武装最为强大的舰只。
同时，扶桑号战列舰也是舰岛最为科幻的战列舰。
当然，要建造这样的舰船，科技水平是必须的。
同样众所周知的是，德意志科学技术天下第一，所以IJN的司令官从德国学来了一种先进的建船方法。
一只战舰横过来可以看做一个长度为n的序列，每个位置有一个数ai表示这个位置设计的高度。这种先进的造船技术可以每次将一个区间[l,r]内的所有位置高度都+,求到达最终设计状态的最少操作次数。
如果你不能及时完成的话，IJN司令官会奖励你去参加苏里高海战。

输入
第一行包含一个整数n，表示序列的长度。
第二行包含n个非负整数a1,a2,a3,…,an，表示最终的状态。

输出
输出的第一行是一个正整数m，表示最少的操作次数。
接下来m行每行两个正整数li,ri，表示一次操作。
你需要保证1≤li≤ri≤n。
保证最少次数m≤，输出可以以任意顺序输出。

样例输入

样例输出

数据范围：n <= ;

•题解

　　由初始状态 n 个 0 ，每次操作 +1，变为 a₁,a₂,...,a_n ；

　　可转化为由最终状态 a₁,a₂,...,a_n，每次操作 -1，变为 n 个 0；

　　由操作次数 m ≤ 10⁵ 可知 a_i ≤ 10⁵；

　　首先用单调栈求出以 a_i 为最小值的左右区间 [l_i,r_i]；

　　然后，从小到大开始枚举 a_i，将 [l_i,r_i] 区间的所有数都减 a_i；

　　区间减数的过程用线段树维护；

　　总的时间复杂度 $O(nlogn)$；

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define ls(x) (x<<1)
 #define rs(x) (x<<1|1)
 const int maxn=1e5+;

 int n;
 int a[maxn];
 vector<int >p[maxn];///ai ≤ 1e5，所以可以开个1e5大小的p存ai出现的位置
 int l[maxn];
 int r[maxn];
 stack<int >sta;
 struct Seg
 {
     int l,r;
     int lazy;
     int val;
     int mid(){return l+((r-l)>>);}
 }seg[maxn<<];
 struct Data
 {
     int l,r;
     int cnt;
 }ans[maxn];

 void buildSegTree(int l,int r,int pos)
 {
     seg[pos].l=l;
     seg[pos].r=r;
     seg[pos].lazy=;

     if(l == r)
     {
         seg[pos].val=a[l];
         return ;
     }
     int mid=l+((r-l)>>);
     buildSegTree(l,mid,ls(pos));
     buildSegTree(mid+,r,rs(pos));
 }
 void pushDown(int pos)
 {
     int &lazy=seg[pos].lazy;

     seg[ls(pos)].lazy += lazy;
     seg[rs(pos)].lazy += lazy;

     lazy=;
 }
 int Query(int x,int pos)
 {
     if(seg[pos].l == seg[pos].r)
         return seg[pos].val-seg[pos].lazy;

     pushDown(pos);

     int mid=seg[pos].mid();

     if(x <= mid)
         return Query(x,ls(pos));
     else
         return Query(x,rs(pos));
 }
 void Updata(int l,int r,int lazy,int pos)
 {
     if(seg[pos].l == l && seg[pos].r == r)
     {
         seg[pos].lazy += lazy;
         return ;
     }
     pushDown(pos);

     int mid=seg[pos].mid();

     if(r <= mid)
         Updata(l,r,lazy,ls(pos));
     else if(l > mid)
         Updata(l,r,lazy,rs(pos));
     else
     {
         Updata(l,mid,lazy,ls(pos));
         Updata(mid+,r,lazy,rs(pos));
     }
 }
 void Clear()
 {
     while(!sta.empty())
         sta.pop();
 }
 void Work()
 {
     Clear();
     for(int i=;i <= n;++i)
     {
         while(!sta.empty() && a[sta.top()] >= a[i])
             sta.pop();

         l[i]=sta.empty() ? :sta.top()+;
         sta.push(i);
     }
     Clear();
     for(int i=n;i >= ;--i)
     {
         while(!sta.empty() && a[sta.top()] >= a[i])
             sta.pop();

         r[i]=sta.empty() ? n:sta.top()-;
         sta.push(i);
     }
 }
 void Solve()
 {
     Work();
     buildSegTree(,n,);

     int k=;
     int x=*max_element(a+,a+n+);
     for(int i=;i <= x;++i)///从小到大枚举ai
     {
         for(int j=;j < p[i].size();++j)
         {
             int id=p[i][j];
             int cur=Query(id,);///线段树查询当前的ai在之前的减法中还剩多少

             if(cur)///cur > 0
             {
                 Updata(l[id],r[id],cur,);///l[id],r[id] 区间做cur次-1操作
                 ans[++k]=Data{l[id],r[id],cur};///记录
             }
         }
     }
     int m=;
     for(int i=;i <= k;++i)
         m += ans[i].cnt;

     printf("%d\n",m);
     for(int i=;i <= k;++i)
         for(int j=;j <= ans[i].cnt;++j)
             printf("%d %d\n",ans[i].l,ans[i].r);
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i <= n;++i)
     {
         scanf("%d",a+i);
         p[a[i]].push_back(i);
     }

     Solve();

     return ;
 }

•简洁做法

　　参考资料：中国石油大学（华东）, 韩宝坤

•我的理解

　　巧妙的利用栈，用很简洁的代码实现了上述很繁琐的程序，tql；

　　首先，如何求解最少的操作次数呢？

　　找上升部分，如下图（ x轴代表点对，y轴代表相应点对到达的高度，n = 9）；

　　

　　在图上虚构两个点，即 0点 和 n+1 点，并使他们的高度为 0；

　　你会发现对紫色部分的操作是必不可少的；

　　例如图中的点 2,3 ，在点 2 下降到 0 位置后，点 3 必定还要再下降一次才可以到达 0 位置；

　　所以所，上升的高度之和便是最少的操作次数，即上图紫色部分的加和；

　　那么如何求解 m 次操作区间呢？

　　找下降部分；

　　对于点 i，如果 a[ i ] > a[ i+1 ] ，那么，通过前面必须要下降的紫色部分让 i 点下降 a[ i ]-a[ i+1 ] 次；

　　使得 i 点与 i+1 点水平；

　　一直执行上述操作，直到来到 n 点，通过前面的紫色部分让 n 点下降到 0 点；

　　至此，执行完毕，共操作 m 次，使得全部点对都置于 0 点；

Code

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=1e5+;

 int n;
 int a[maxn];
 stack<int >sta;

 void Solve()
 {
     int m=;
     for(int i=;i <= n;++i)
     {
         if(a[i] > a[i-])
             m += a[i]-a[i-];
     }

     printf("%d\n",m);

     for(int i=;i <= n;++i)
     {
         if(a[i] > a[i-])
         {
             for(int j=a[i-];j < a[i];++j)
                 sta.push(i);
         }
         if(a[i] > a[i+])
         {
             ///不用特判sta是否为空，因为下降前必定会有上升，上升的高度必然>=下降的高度
             for(int j=a[i];j > a[i+];--j)
             {
                 printf("%d %d\n",sta.top(),i);
                 sta.pop();
             }
         }
     }
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i <= n;++i)
         scanf("%d",a+i);

     Solve();

     return ;
 }