题目

题目描述
春春是一名道路工程师，负责铺设一条长度为 $n$的道路。
铺设道路的主要工作是填平下陷的地表。整段道路可以看作是 $n$块首尾相连的区域，一开始，第 $i$块区域下陷的深度为 $d_i$。
春春每天可以选择一段连续区间 $[L,R]$，填充这段区间中的每块区域，让其下陷深度减少 $1$。在选择区间时，需要保证，区间内的每块区域在填充前下陷深度均不为 $0$。
春春希望你能帮他设计一种方案，可以在最短的时间内将整段道路的下陷深度都变为 $0$。

输入输出格式
输入格式
输入文件包含两行，第一行包含一个整数 $n$，表示道路的长度。 第二行包含 $n$个整数，相邻两数间用一个空格隔开，第 $i$个整数为 $d_i$。
输出格式
输出文件仅包含一个整数，即最少需要多少天才能完成任务。

输入输出样例
输入样例：
6
4 3 2 5 3 5
输出样例：
9

样例解释
一种可行的最佳方案是，依次选择： $[1,6]$、 $[1,6]$、 $[1,2]$、 $[1,1]$、 $[4,6]$、 $[4,4]$、 $[4,4]$、 $[6,6]$、 $[6,6]$。

数据规模与约定
对于 $30\%$的数据， $1\leq n\leq 10$；
对于 $70\%$的数据， $1\leq n\leq 1000$；
对于 $100\%$的数据， $1\leq n\leq 100000$ ， $0\leq d_i\leq 10000$。

思路

考场

看完题直接线段树+分治 $30$分钟过大样例。
对于区间 $[l,r]$，其中的最小值就是这个区间整体上升（铺路）的高度。
把区间从最小值分成很多（因为可能有多个最小值）段，分治。

考场代码

#include<cstdio>
#include<algorithm>
using namespace std;

int read(){
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

#define MAXN 100000
#define INF 0x3f3f3f3f
#define LL long long
int N;
int D[MAXN+5];
struct node{
    int l,r,Min;
}Tree[(MAXN<<2)+5];

void Build(int i,int l,int r){
    Tree[i].l=l,Tree[i].r=r,Tree[i].Min=INF;
    if(l==r)
        return;
    int mid=(l+r)>>1;
    Build(i*2,l,mid);
    Build(i*2+1,mid+1,r);
}
void Insert(int i,int l,int r,int x){
    if(r<Tree[i].l||Tree[i].r<l)
        return;
    if(l<=Tree[i].l&&Tree[i].r<=r){
        Tree[i].Min=min(Tree[i].Min,x);
        return;
    }
    Insert(i*2,l,r,x);
    Insert(i*2+1,l,r,x);
    Tree[i].Min=min(Tree[i*2].Min,Tree[i*2+1].Min);
}
int Ask(int i,int l,int r){
    if(r<Tree[i].l||l>Tree[i].r)
        return INF;
    if(l<=Tree[i].l&&Tree[i].r<=r)
        return Tree[i].Min;
    return min(Ask(i*2,l,r),Ask(i*2+1,l,r));
}

LL Solve(int l,int r,int delta){
    if(l>r)
        return 0;
    int t=Ask(1,l,r),Last=l;
    LL ret=t-delta;
    for(int i=l;i<=r;i++)
        if(D[i]==t)
            ret=ret+Solve(Last,i-1,t),Last=i+1;
    return ret+Solve(Last,r,t);
}

int main(){
    freopen("road.in" ,"r", stdin);
    freopen("road.out","w",stdout);
    N=read();
    Build(1,1,N);
    for(int i=1;i<=N;i++){
        D[i]=read();
        Insert(1,i,i,D[i]);
    }
    printf("%lld",Solve(1,N,0));
}

洛谷上过了。

hack

这玩意最坏时间是： $n+(n-1)+(n-2)+...+1=\dfrac{n(n-1)}{2}$（即序列是递增的时候，每次删最开始一个）， $O(n^2)$， $1\leq n\leq 10^5$，GG。
但是 $0\leq d_i\leq 10^4$，好像无法完全递增，那就前 $10^4$个递增，后面全部是 $10^4$，完美TLE。
点这里去试试是不是TLE。

题外话

写到这里真的想把自己砍死。
区间最小值非要用线段树！！！
于是发现直接枚举区间中的每个元素找到最小值就可以了。
因为我分段的时候还要扫一遍，所以Ask函数的 $O(logN)$没有任何用。

AC代码：

#include<cstdio>
#include<algorithm>
using namespace std;

int read(){
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

#define MAXN 100000
#define INF 0x3f3f3f3f
#define LL long long
int N;
int D[MAXN+5];

LL Solve(int l,int r,int delta){
    if(l>r)
        return 0;
    int t=INF,Last=l;
    for(int i=l;i<=r;i++)
        t=min(t,D[i]);//。。。。。。
    LL ret=t-delta;
    for(int i=l;i<=r;i++)
        if(D[i]==t)
            ret=ret+Solve(Last,i-1,t),Last=i+1;
    return ret+Solve(Last,r,t);
}

int main(){
    //freopen("road.in" ,"r", stdin);
    //freopen("road.out","w",stdout);
    N=read();
    for(int i=1;i<=N;i++)
        D[i]=read();
    printf("%lld",Solve(1,N,0));
}

如果真的要用线段树优化时间的话，就要把最小值的位置记录下来，以避免再扫一遍。

正解

我只能勉强理解这种玄学思路。

如果 $d_i\geq d_{i+1}$，那么修好 $d_i$后 $d_{i+1}$一定能被修好，不需要额外修 $d_{i+1}$；
否则，就需要额外花费 $d_{i+1}-d_i$来修好 $d_{i+1}$。

代码：

#include<map>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;

int read(){
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*f;
}

int N,Last;
long long Ans;

int main(){
    N=read();
    for(int i=1;i<=N;i++){
        int A=read();
        Ans+=(Last<A)*(A-Last);
        Last=A;
    }
    printf("%lld",Ans);
}