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

传送门

 

•题目描述

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

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

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

样例输入
6
2 3 3 3 3 3

样例输出
3
1 6
1 6
2 6

数据范围：n <= 100000;

•题解

　　由初始状态 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+50;

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)>>1);}
}seg[maxn<<4];
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=0;

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

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

    lazy=0;
}
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+1,r,lazy,rs(pos));
    }
}
void Clear()
{
    while(!sta.empty())
        sta.pop();
}
void Work()
{
    Clear();
    for(int i=1;i <= n;++i)
    {
        while(!sta.empty() && a[sta.top()] >= a[i])
            sta.pop();

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

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

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

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

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

    Solve();

    return 0;
}

•简洁做法

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

•我的理解

　　巧妙的利用栈，用很简洁的代码实现了上述很繁琐的程序，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+50;

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

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

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

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

    Solve();

    return 0;
}