[IOI2014]holiday 假期 题解

[IOI2014]holiday 假期 题解

Problem

​ 给定一个序列，序列上每一个点有点权，给定一个出发点和一个花费，每次可以用1的花费在相邻两点间移动，也可以用1的花费获取当前点的点权的价值，每个点只可以被获取一次，求最大价值。

Solution

​ 很容易发现，最优方法一定是先一直朝一个方向走，之后再看是否回头朝另一个方向走。

​ 那么我们可以把这个问题分成四个小问题，我们设\(f_{1,i},f_{2.i},f_{3,i},f_{4,i}\)分别表示花费为\(i\)，向左/向右/向左后回到起点/向右后回到起点的最大价值，由它们组合得到答案。

​ \(O(n^2logn)\)的DP是不难想到的，只要枚举最远到达的点，之后再用除去走完一遍路程的剩余的花费\(k\)在这段路程中选最大的\(k\)个价值即可，可以用主席树维护。

​ 考虑如何去优化这个DP，我们可以发现，每当有更多的可支配花费，最优的最远到达点只增不减，具有决策单调性，这个性质也比较明显。

​ 接下来，考虑如何实现，我们可以用决策单调性一个很常见的办法：分治来实现优化。具体而言，类似于整体二分一样。

​ 这道题细节很多，我写了一天，心态数次炸裂，最终终于完成，下面说说几个坑点：

​ 1.单调栈不好写这道题！我一开始写的是单调栈，最终感觉不好写，只有50pts，改换了分治。

​ 2.主席树注意判一下查询区间是否为空。

​ 3.\(m\)的范围不是1e5......

​ 4.最恶心的一点，注意起点的权值不要算到两次。

Code

#include<bits/stdc++.h>
#define LL long long
using namespace std;
int n,m,k;
int d[100005],t[100005],pos[300005],root[100005];
LL Ans,f1[300005],f2[300005],f3[300005],f4[300005];//L,R,L->R,R->L

struct Segment_Tree{

    int tot;

    LL sum[2000005];

    int seg[2000005],son[2000005][2];

    void insert(int &k,int p,int l,int r,int pos){
        k=++tot;
        seg[k]=seg[p]+1;
        son[k][0]=son[p][0];
        son[k][1]=son[p][1];
        sum[k]=sum[p]+t[pos];
        if(l==r)
            return;
        int mid=l+r>>1;
        if(pos<=mid)
            insert(son[k][0],son[p][0],l,mid+0,pos);
        else
            insert(son[k][1],son[p][1],mid+1,r,pos);
        return;
    }

    LL query(int k,int p,int l,int r,int kth){
        if(l==r)
            return 1LL*kth*t[l];
        LL res=0;
        int mid=l+r>>1;
        if(seg[son[k][1]]-seg[son[p][1]]>=kth)
            res+=query(son[k][1],son[p][1],mid+1,r,kth);
        else{
            res+=sum[son[k][1]]-sum[son[p][1]];
            res+=query(son[k][0],son[p][0],l,mid+0,kth-(seg[son[k][1]]-seg[son[p][1]]));
        }
        return res;
    }

    LL Query(int l,int r,int k){
        return l>r?0:query(root[r],root[l-1],1,n,min(k,r-l+1));
    }

}T;

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

void solve1(int l,int r,int L,int R){
    if(l>r)
        return;
    int mid=l+r>>1;
    for(register int i=L;i<=R;++i){
        if(mid-(k-i<<0)<0)
            continue;
        LL res=T.Query(i,k,mid-(k-i<<0));
        if(!pos[mid]||res>f1[mid]){
            pos[mid]=i;
            f1[mid]=res;
        }
    }
    solve1(l,mid-1,pos[mid],R);
    solve1(mid+1,r,L,pos[mid]);
    return;
}

void solve2(int l,int r,int L,int R){
    if(l>r)
        return;
    int mid=l+r>>1;
    for(register int i=L;i<=R;++i){
        if(mid-(i-k<<0)<0)
            continue;
        LL res=T.Query(k,i,mid-(i-k<<0));
        if(!pos[mid]||res>f2[mid]){
            pos[mid]=i;
            f2[mid]=res;
        }
    }
    solve2(l,mid-1,L,pos[mid]);
    solve2(mid+1,r,pos[mid],R);
    return;
}

void solve3(int l,int r,int L,int R){
    if(l>r)
        return;
    int mid=l+r>>1;
    for(register int i=L;i<=R;++i){
        if(mid-(k-i<<1)<0)
            continue;
        LL res=T.Query(i,k-1,mid-(k-i<<1));
        if(!pos[mid]||res>f3[mid]){
            pos[mid]=i;
            f3[mid]=res;
        }
    }
    solve3(l,mid-1,pos[mid],R);
    solve3(mid+1,r,L,pos[mid]);
    return;
}

void solve4(int l,int r,int L,int R){
    if(l>r)
        return;
    int mid=l+r>>1;
    for(register int i=L;i<=R;++i){
        if(mid-(i-k<<1)<0)
            continue;
        LL res=T.Query(k+1,i,mid-(i-k<<1));
        if(!pos[mid]||res>f4[mid]){
            pos[mid]=i;
            f4[mid]=res;
        }
    }
    solve4(l,mid-1,L,pos[mid]);
    solve4(mid+1,r,pos[mid],R);
    return;
}

int main(){
    
    n=read();k=read();m=read();++k;

    for(register int i=1;i<=n;++i)
        d[i]=t[i]=read();

    sort(t+1,t+n+1);

    for(register int i=1;i<=n;++i){
        d[i]=lower_bound(t+1,t+n+1,d[i])-t;
        T.insert(root[i],root[i-1],1,n,d[i]);
    }

    memset(pos,0,sizeof pos);solve1(1,m,max(1,k-(m>>0)),k);

    memset(pos,0,sizeof pos);solve2(1,m,k,min(n,k+(m>>0)));

    memset(pos,0,sizeof pos);solve3(1,m,max(1,k-(m>>1)),k);

    memset(pos,0,sizeof pos);solve4(1,m,k,min(n,k+(m>>1)));

    for(register int i=0;i<=m;++i)
        Ans=max(Ans,max(f1[i]+f4[m-i],f2[i]+f3[m-i]));

    printf("%lld\n",Ans);

    return 0;
}