BZOJ4367 IOI2014holiday假期（整体二分+主席树）

　　显然最优策略是先走到一边要到达的最远城市，再换方向走到另一边要到达的最远城市（当然也可以直接停止），路上参观景点。

　　先仅考虑求出只向左走，花费时间i时的最优解。如果能求出这个，类似的就可以求出所有情况。

　　显然时间越长，应该往左边走的越远，参观的越多，但是这个最远城市的变化不一定连续，没法愉快地双指针或者直接二分答案。

　　考虑类似整体二分的做法。设当前要求i在l~r，最远城市在x~y之间的最优解，对i=mid暴力求出最优解，然后递归处理两边。暴力需要进行nlog次，每次暴力需要求区间k大和，可以用主席树做到log，于是复杂度O(nlog²n)。

　　注意起点处只能取一次。并且对mid求出的最远点如果有多解考虑清楚选哪一个。

　　upd：才想起来这玩意就是决策单调性

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cassert>
using namespace std;
int read()
{
    int x=,f=;char c=getchar();
    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}
    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();
    return x*f;
}
#define N 100010
#define ll long long
int n,start,m,a[N],b[N],root[N],cnt,t;
ll fl[N<<],gl[N<<],fr[N<<],gr[N<<];
struct data{int l,r,x;ll sum;
}tree[N*];
struct data2{ll x;int d;};
void ins(int &k,int l,int r,int x)
{
    tree[++cnt]=tree[k],k=cnt;
    tree[k].x++,tree[k].sum+=b[x];
    if (l==r) return;
    int mid=l+r>>;
    if (x<=mid) ins(tree[k].l,l,mid,x);
    else ins(tree[k].r,mid+,r,x);
}
ll query(int x,int y,int l,int r,int k)
{
    if (!y) return ;
    if (l==r) return 1ll*min(tree[y].x-tree[x].x,k)*b[l];
    int mid=l+r>>,t=tree[tree[y].r].x-tree[tree[x].r].x;
    if (t>=k) return query(tree[x].r,tree[y].r,mid+,r,k);
    else return tree[tree[y].r].sum-tree[tree[x].r].sum+query(tree[x].l,tree[y].l,l,mid,k-t);
}
data2 calc(int tot,int x,int y,int op,int isr)
{
    int mx=isr?x:y;ll ans=;
    if (isr)
    {
        for (int i=x;i<=y;i++)
        if (tot>=abs(start-i)*(+op))
        {
            ll v;
            if (i<start) v=query(root[i-],root[start-op],,t,tot-(start-i)*(+op));
            else v=query(root[start-+op],root[i],,t,tot-(i-start)*(+op));
            if (v>ans) ans=v,mx=i;
        }
    }
    else
    {
        for (int i=y;i>=x;i--)
        if (tot>=abs(start-i)*(+op))
        {
            ll v;
            if (i<start) v=query(root[i-],root[start-op],,t,tot-(start-i)*(+op));
            else v=query(root[start-+op],root[i],,t,tot-(i-start)*(+op));
            if (v>ans) ans=v,mx=i;
        }
    }
    return (data2){ans,mx};
}
void solve1(int l,int r,int x,int y)
{
    if (l>r||x>y) return;
    int mid=l+r>>;data2 t=calc(mid,x,y,,);
    fl[mid]=t.x;
    solve1(l,mid-,t.d,y);
    solve1(mid+,r,x,t.d);
}
void solve2(int l,int r,int x,int y)
{
    if (l>r||x>y) return;
    int mid=l+r>>;data2 t=calc(mid,x,y,,);
    fr[mid]=t.x;
    solve2(l,mid-,x,t.d);
    solve2(mid+,r,t.d,y);
}
void solve3(int l,int r,int x,int y)
{
    if (l>r||x>y) return;
    int mid=l+r>>;data2 t=calc(mid,x,y,,);
    gl[mid]=t.x;
    solve3(l,mid-,t.d,y);
    solve3(mid+,r,x,t.d);
}
void solve4(int l,int r,int x,int y)
{
    if (l>r||x>y) return;
    int mid=l+r>>;data2 t=calc(mid,x,y,,);
    gr[mid]=t.x;
    solve4(l,mid-,x,t.d);
    solve4(mid+,r,t.d,y);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("bzoj4367.in","r",stdin);
    freopen("bzoj4367.out","w",stdout);
    const char LL[]="%I64d\n";
#else
    const char LL[]="%lld\n";
#endif
    n=read(),start=read()+,m=read();
    for (int i=;i<=n;i++) b[i]=a[i]=read();
    sort(b+,b+n+);
    t=unique(b+,b+n+)-b-;
    for (int i=;i<=n;i++) a[i]=lower_bound(b+,b+t+,a[i])-b;
    for (int i=;i<=n;i++)
    {
        root[i]=root[i-];
        ins(root[i],,t,a[i]);
    }
    solve1(,m,,start);
    solve2(,m,start,n);
    solve3(,m,,start-);
    solve4(,m,start+,n);
    ll ans=;
    for (int i=;i<=m;i++)
    ans=max(ans,gl[i]+fr[m-i]),
    ans=max(ans,gr[i]+fl[m-i]);
    cout<<ans;
    return ;
}