Description:

有一條類似$x$軸的河上，有$n$個點，每個點有開放的時間$t_i$，座標$p_i$，權值$w_i$。 初始在座標$S$處，你可以去其它點後並會來，而逆流而上每個單位的花費為$U$，順溜而下每個單位的花費為$D$。求最後獲得的權值最大為多少。 $n,t_i \le 500000,S,p_i\le 500001,w_i\le4000,D\le U\le10$

Solution:

• 一道比較傳統的題
• 首先是一個$\Theta(n^2)$的$dp$，這個都沒有問題
• 那麼發現這個逆流而上和順流而下可以分類討論一下，這樣就可以通過線段樹（BIT）來維護區間的逆流而上的和順流而下的最大值即可。
• 這樣複雜度為$\Theta(n\log n)$

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T &x,T y){return x<y?x=y,1:0;}
template<class T>inline void Rd(T &x){
	x=0;char c;
	while((c=getchar())<48);
	do x=(x<<1)+(x<<3)+(c^48);
	while((c=getchar())>47);
}

const int N=500005;

int n,U,D,S; 

struct node{
	int t,p,w;
	bool operator<(const node &_)const{
		return t!=_.t?t<_.t:p<_.p; 
	}
}A[N];

int dp[N];
struct p45{
	 
	int dis(int s,int t){
		if(s>=t) return (s-t)*U;
		else return (t-s)*D;
	}
	
	void solve(){
		
		REP(i,1,n) dp[i]=A[i].w-dis(S,A[i].p);
		
		int ans=0;
		
		REP(i,1,n) {
			SREP(j,1,i){
				if(A[i].t==A[j].t)continue;
				chkmax(dp[i],dp[j]+A[i].w-dis(A[j].p,A[i].p));
			}
			chkmax(ans,dp[i]-dis(A[i].p,S));
		}
		
		printf("%d\n",ans);
	}
}p1;

struct p100{
	int mx[2][N<<2];
	
	void build(int p,int L,int R) {
		if(L==R){
			if (L==S) mx[0][p]=D*S,mx[1][p]=-U*S;
			else mx[0][p]=mx[1][p]=-0x3f3f3f3f;
			return;
		}
		int mid=(L+R)/2;
		build(p<<1,L,mid);
		build(p<<1|1,mid+1,R);
		mx[0][p]=max(mx[0][p<<1],mx[0][p<<1|1]);
		mx[1][p]=max(mx[1][p<<1],mx[1][p<<1|1]);
	}
	
	void update(int p,int L,int R,int k) {
		if(L==R){
			mx[0][p]=dp[k]+D*A[k].p;
			mx[1][p]=dp[k]-U*A[k].p;
			return;
		}
		int mid=(L+R)/2;
		if(A[k].p<=mid)update(p<<1,L,mid,k);
		else update(p<<1|1,mid+1,R,k);
		mx[0][p]=max(mx[0][p<<1],mx[0][p<<1|1]);
		mx[1][p]=max(mx[1][p<<1],mx[1][p<<1|1]);
	}
	
	int query(int f,int p,int L,int R,int l,int r) {
		if(l<=L&&R<=r) return mx[f][p];
		int mid=(L+R)/2,res=-0x3f3f3f3f;
		if(l<=mid) res=query(f,p<<1,L,mid,l,r);
		if(r>mid) chkmax(res,query(f,p<<1|1,mid+1,R,l,r));
		return res;
	}
	
	int f[N],g[N];
	
	void solve(){
		A[++n]=(node){A[n-1].t+1,S,0};
		
		int m=S;
		REP(i,1,n) chkmax(m,A[i].p);
		build(1,1,m);
		
		for(int i=1,j;i<=n;i=j+1){
			for(j=i;j<n && A[j+1].t==A[i].t;++j);

			REP(k,i,j) dp[k]=max(query(0,1,1,m,1,A[k].p)-D*A[k].p,query(1,1,1,m,A[k].p,m)+U*A[k].p)+A[k].w;

			f[i]=dp[i];
			REP(k,i+1,j) f[k]=max(dp[k],f[k-1]-D*(A[k].p-A[k-1].p)+A[k].w);

			g[j]=dp[j];
			DREP(k,j-1,i) g[k]=max(dp[k],g[k+1]-U*(A[k+1].p-A[k].p)+A[k].w);

			REP(k,i,j) chkmax(dp[k],max(f[k],g[k])),update(1,1,m,k);
		}
		printf("%d\n",dp[n]);
	}
}p2;

int main(){
//	freopen("salesman.in","r",stdin);
//	freopen("salesman.out","w",stdout);
	Rd(n),Rd(U),Rd(D),Rd(S);
	REP(i,1,n) Rd(A[i].t),Rd(A[i].p),Rd(A[i].w);
	sort(A+1,A+1+n);
	
	if(n<=5000)p1.solve();
	else p2.solve();
	
	return 0;
}