「IOI2009」旅行商

题目传送门

首先，看到这道题感觉就像dp（然鹅没什么用）。

一个美好的设想

假如没有两个展销会在同一天开展：前途光明

暴力dp，复杂度o((n^2))。

没有同一天的展销会

暴力dp慢，是因为本质上很多状态都是没有什么用的（或者说可以压缩）。

那么可以考虑将一个区间的信息压缩到点上。

先把一段区间均分为左半部分和右半部分。

假如A这个点有展销会，那么左半部分就会向右走。

考虑把左半部分的信息压缩到端点，这个还是比较简单的，如果左半部分有开展过展销会，那么顺便把左右端点的值给更新掉。这样就快速的将左半部分的值转移到A点。

再转到剩下右半部分。

继续把区间切成两半，同理将右半部分的信息转移到A点，对左半部分进行递归处理。

那么现在假设A点已经处理好了。要进行信息的更新。

首先，左右端点肯定是需要的。对于切割点同样也要更新（仅仅更新左右端点是无法处理这种情况的）。

于是一个展销会就被处理好了，一次的复杂度为o(log(n))。

有同一天的展销会

还是要面对有展销会在同一天的事实。。。

其实，同一天的展销会可以按照所在位置进行排序，然后按照某个顺序dp下去（我总不可能先←再→然后←，明显的浪费钱），所以只要正序，倒序各自dp一遍即可。

然而信息不能相互干扰，所以需要一个中间数组来存储某一个顺序的dp结果（当然不需要全部的信息，只需要展销会所在的点，再另行更新），而另一顺序直接放到原数组里就好了。

由于这个写法保证了每个点都会包括到一个或多个可以更新答案的点（并且保证可以以最优的方式转移），所以直接按顺序dp下来并没有什么问题（相当于先移动到一个点，再单方向移动，囊括了 先←再→ 以及 先→再← 的方案）。所以70pts和100pts思路没有区别。

这样这道题就好了 （假装讲明白了）。

code

#include<bits/stdc++.h>
#define unable AC
#define KLL dying
#define re register int
#define rep(q,a,b) for(re q(a),q##_end_(b);q<=q##_end_;++q)
#define dep(q,a,b) for(re q(a),q##_end_(b);q>=q##_end_;--q)
#define mem(a,b) memset(a,b,sizeof a)
using namespace std;
void in(int &r) {
    static char c;
    r=0;
    while(c=getchar(),!isdigit(c));
    do r=(r<<1)+(r<<3)+(c^48);
    while(c=getchar(),isdigit(c));
}
const int mn=500005;
int val[mn],n,n_cost,s_cost,st;
struct node {
    int tim,at,val;
    bool operator <(const node &A)const {
        return tim==A.tim?at<A.at:tim<A.tim;
    }
} qw[mn];
int len_max,Max,at,adv,md[mn];
int dis(int l,int r) {
    if(l<r)return (r-l)*s_cost;
    return (l-r)*n_cost;
}
 
void mid_add(int l,int r) {
    md[l]=max(md[l],val[l]),md[r]=max(md[r],val[r]);
    if(l==r)md[l]=max(md[l],Max+adv);
    else {
        Max=max(Max,md[l]-dis(l,at));
        Max=max(Max,md[r]-dis(r,at));
        int mid=l+r>>1;
        if(at>mid) {
            mid_add(mid+1,r);
            md[mid]=max(md[mid],val[mid]);
            md[mid]=max(md[mid],md[at]-dis(at,mid));
        } else {
            mid_add(l,mid);
            md[mid+1]=max(md[mid+1],val[mid+1]);
            md[mid+1]=max(md[mid+1],md[at]-dis(at,mid+1));
        }
        md[l]=max(md[l],md[at]-dis(at,l));
        md[r]=max(md[r],md[at]-dis(at,r));
    }
}
void add(int l,int r) {
    if(l==r)val[l]=max(val[l],Max+adv);
    else {
        Max=max(Max,val[l]-dis(l,at));
        Max=max(Max,val[r]-dis(r,at));
        int mid=l+r>>1;
        if(at>mid) {
            add(mid+1,r);
            val[mid]=max(val[mid],val[at]-dis(at,mid));
        } else {
            add(l,mid);
            val[mid+1]=max(val[mid+1],val[at]-dis(at,mid+1));
        }
        val[l]=max(val[l],val[at]-dis(at,l));
        val[r]=max(val[r],val[at]-dis(at,r));
    }
}
void replace(int l,int r) {
    if(l==r)val[l]=max(val[l],adv);
    else {
        int mid=l+r>>1;
        if(at>mid) {
            replace(mid+1,r);
            val[mid]=max(val[mid],val[at]-dis(at,mid));
        } else {
            replace(l,mid);
            val[mid+1]=max(val[mid+1],val[at]-dis(at,mid+1));
        }
        val[l]=max(val[l],adv-dis(at,l));
        val[r]=max(val[r],adv-dis(at,r));
    }
}
void solve() {
    rep(q,1,len_max)val[q]=-dis(st,q),md[q]=val[q];
    int now=1;
    while(now<=n) {
        int last=now;
        while(qw[now+1].tim==qw[now].tim)++now;
        rep(q,last,now) {
            Max=-1e9,adv=qw[q].val,at=qw[q].at;
            mid_add(1,len_max);
        }
        dep(q,now,last) {
            Max=-1e9,adv=qw[q].val,at=qw[q].at;
            add(1,len_max);
        }
        rep(q,last,now){
            adv=md[qw[q].at];
            at=qw[q].at;
            replace(1,len_max);
        }
        ++now;
    }
    int ans=0;
    rep(q,1,len_max)ans=max(ans,val[q]-dis(q,st));
    cout<<ans;
}
int main() {
//    freopen("salesman.in","r",stdin);
//    freopen("salesman.out","w",stdout);
    in(n),in(n_cost),in(s_cost),in(st);
    len_max=st;
    rep(q,1,n)in(qw[q].tim),in(qw[q].at),in(qw[q].val),len_max=max(len_max,qw[q].at);
    sort(qw+1,qw+n+1);
    solve();
    return 0;
}