【NOIP2018提高组】D1T1 铺设道路

题目

题目描述
春春是一名道路工程师，负责铺设一条长度为$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\le n\le 10$；
对于$70\%$的数据，$1\le n\le 1000$；
对于$100\%$的数据，$1\le n\le 100000$ ，$0\le d_i\le 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=\frac{n(n-1)}{2}$（即序列是递增的时候，每次删最开始一个），$O(n^2)$，$1\le n\le 10^5$，GG。
但是$0\le d_i\le 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\ge 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);
}