[海军国际项目办公室]门童

门童

题目概述

题解

妹妹最爱的树套树优化dp。

首先应该很容易 come up with 一种$dp$的思路。
由于牛牛整个过程中只有两个动作，待在门口，跑回去休息又跑回来。
我们可以定义$d{p}_{i,0/1}$表示牛牛现在是待在门口还是再休息，但这样的话处理接待客人是很麻烦的，可能还要状压，我们不如就只看他待在门口接待客人的时候。
定义$d{p}_i$表示他在时间$i$时待在门口的总贡献，有两种转移，一种就是上一个时刻也待在门口，一种是从之前某个时刻跑回去休息，现在跑回来。
第一种的话客人一来就可以接待，直接加上客人的总价值就行了。
而第二种相当于在这段区间的客人来的时候，你是不会接待他们的，只有当你跑会来时才会接待他们，这就要算中间这段时间的贡献了。
我们同时发现，这样的转移第二种转移同时也是有区间的限制的，你不可能完全错过某个客人。

但我们发现如果像我们上面说的这样$dp$的话，我们发现真正有效的时间节点只有某个人到来的时间和某个人离开的时间。
因为我们的$dp$转移产生的贡献事实上都是斜率固定的直线的形式，所以加起来我们的最优决策点肯定时在某个时间节点上的。
我们可以只拿时间节点来作为$dp$状态，定义第$i$个时间节点为$b_i$。
显然可以得到$dp$转移式，
$$d{p}_i=\max \left(d{p}_{i-1}-(b_i-b_{i-1})x_{0,0}+\sum _{t_k\in (b_{i-1},b_i]}{f}_k{p}_k,\underset{j=L_i}{\overset{R_i}{\max }}\left(d{p}_j-L(x_{1,0}+x_{0,1}+2x_{1,1})+(b_i-b_j-2L)x_{1,1}+\sum _{t_k\in (b_{i-1},b_i]}{f}_k(t_k+p_k-b_i)\right)\right)$$
对于$L_i$和$R_i$，这两者显然是不降的，我们应该可以很容易地$O\left(n\right)$处理出来。
而对于上面的$dp$式子，我们是可以再化一下的，
$$d{p}_i=\max \left(d{p}_{i-1}-(b_i-b_{i-1})x_{0,0}+\sum _{t_k\in (b_{i-1},b_i]}{f}_k{p}_k,b_i{x}_{1,1}-L(x_{1,0}+x_{0,1}+2x_{1,1})+\underset{j=L_i}{\overset{R_i}{\max }}\left(d{p}_j-b_j{x}_{1,1}+\sum _{t_k\in (b_{i-1},b_i]}{f}_k(t_k+p_k-b_i)\right)\right)$$
这样的话其实是比较显而易见的斜率优化了，我们再看一看，化简一下，
定义$su{m}_i={\sum }_{t_k⩽b_i}{f}_k(t_k+p_k)$,$sum{p}_i={\sum }_{t_k⩽b_i}{f}_k{p}_k$,$sum{f}_i={\sum }_{t_k⩽b_i}{f}_k$
那么有
$$d{p}_i=\max \left(d{p}_{i-1}-(b_i-b_{i-1})x_{0,0}+sum{p}_i-sum{p}_{i-1},b_i{x}_{1,1}-L(x_{1,0}+x_{0,1}+2x_{1,1})+\underset{j=L_i}{\overset{R_i}{\max }}\left(d{p}_j+su{m}_i-su{m}_j-b_j{x}_{1,1}+(sum{f}_i-sum{f}_j)b_i\right)\right)$$
前面定义$cos{t}_i=(b_i-b_{i-1})x_{0,0}+sum{p}_i-sum{p}_{i-1}$，再将后面根据与$i$有关还是与$j$有关划分一下，与$j$无关的提出来。
定义$A_i=b_i{x}_{1,1}-L(x_{1,0}+x_{0,1}+2x_{1,1})+su{m}_i+sum{f}_i{b}_i$,$B_j=d{p}_j-su{m}_j-b_j{x}_{1,1}$,$C_j=sum{f}_j$,$D_i=b_i$，
那么原式就成了：
$$d{p}_i=\max \left(d{p}_{i-1}+cos{t}_i,A_i+\underset{j=L_i}{\overset{R_i}{\max }}(B_j+C_j{D}_i)\right)$$
十分明显的斜率优化式子了，对于每个$d{p}_i$，都有固定的$x=D_i$与$A_i$，要在前面$[L_i,R_i]$中找到直线$y=B_j+C_{j}x$找到最大的来转移。
既然是直线的转移，那便很容易想到通过李超线段树来维护了。
不过即使$L_i,R_i$是递增的，李超线段树也不好维护呀，优先队列的做法我又打不来。
但是我们可以树套树呀，外层线段树维护区间，内层李超线段树维护我们的线段，这样就可以了。
树套树优化$dp$毕竟是传统艺能嘛。
其实也可以用分块来维护，这样空间可能会小一点，但时间复杂度会大一点。
但没关系，小常数都跑得很快。
就这样跑一道$dp$就可以了。

时间复杂度$O\left(n{\log }^{2}n\right)$(树套树)或者$O\left(n\sqrt{n\log n}\right)$(分块)。
优先队列好像可以做到$O\left(n\log n\right)$。
至于标程的$O\left(n{\log }^{2}n\right)$李超树怎么弄的我没看懂。

源码

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005
#define lowbit(x) (x&-x)
#define reg register
#define pb push_back
#define mkpr make_pair
#define fir first
#define sec second
typedef long long LL;
typedef unsigned long long uLL;       
const LL INF=0x3f3f3f3f3f3f3f3f;       
const int mo=1e9+7;
const int inv2=499122177;
const int jzm=2333;
const int zero=10000;
const int orG=3,invG=332748118;
const double Pi=acos(-1.0);
const double eps=1e-5;
typedef pair<LL,int> pii;
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
	_T f=1;x=0;char s=getchar();
	while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
	while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
	x*=f;
}
template<typename _T>
void print(_T x){if(x<0){x=(~x)+1;putchar('-');}if(x>9)print(x/10);putchar(x%10+'0');}
int gcd(int a,int b){return !b?a:gcd(b,a%b);}
int add(int x,int y,int p){return x+y<p?x+y:x+y-p;}
void Add(int &x,int y,int p){x=add(x,y,p);}
struct ming{int f,t,p;}s[MAXN];
struct line{
	LL k,b;line(){k=0;b=-1e15;}
	line(LL K,LL B){k=K;b=B;}
	LL ask(const int x){return 1ll*x*k+b;}
};
int n,L,x00,x01,x10,x11,b[MAXN],tott,dL[MAXN],dR[MAXN],d[MAXN];
LL dp[MAXN],sumf[MAXN],summ[MAXN],ans,sump[MAXN];
struct tann{line s;int lson,rson;};
class SegmentTree{
	private:
		tann tr[MAXN*100];int tot,root[MAXN<<2];
		void insert(int &rt,int l,int r,line aw){
			if(l>r)return ;if(!rt)rt=++tot;int mid=l+r>>1;
			if(tr[rt].s.ask(b[mid])<aw.ask(b[mid]))swap(tr[rt].s,aw);
			if(l<mid&&tr[rt].s.ask(b[l])<aw.ask(b[l]))insert(tr[rt].lson,l,mid-1,aw);
			if(r>mid&&tr[rt].s.ask(b[r])<aw.ask(b[r]))insert(tr[rt].rson,mid+1,r,aw);
		}
		LL query(int rt,int l,int r,int ai){
			if(l>ai||r<ai||!rt)return -INF;
			int mid=l+r>>1;LL res=tr[rt].s.ask(b[ai]);
			if(ai<mid)res=max(res,query(tr[rt].lson,l,mid-1,ai));
			if(ai>mid)res=max(res,query(tr[rt].rson,mid+1,r,ai));
			return res;
		}
	public:
		#define lson (rt<<1)
		#define rson (rt<<1|1)
		void Insert(int rt,int l,int r,int ai,line aw){
			if(l>ai||r<ai)return ;int mid=l+r>>1;
			insert(root[rt],0,tott,aw);if(l==r)return ;
			if(ai<=mid)Insert(lson,l,mid,ai,aw);
			else Insert(rson,mid+1,r,ai,aw);
		}
		LL Query(int rt,int l,int r,int al,int ar,int ai){
			if(l>r||l>ar||r<al||al>ar)return -INF;
			if(al<=l&&r<=ar)return query(root[rt],0,tott,ai);
			int mid=l+r>>1;LL res=-INF;
			if(al<=mid)res=max(res,Query(lson,l,mid,al,ar,ai));
			if(ar>mid)res=max(res,Query(rson,mid+1,r,al,ar,ai));
			return res;
		}
		#undef lson
		#undef rson
}T;
signed main(){
	freopen("D.in","r",stdin);
	freopen("D.out","w",stdout);
	read(n);read(L);int maxx=0;
	read(x00);read(x01);read(x10);read(x11);
	for(int i=1;i<=n;i++)
		read(s[i].t),read(s[i].p),read(s[i].f),
		b[++tott]=s[i].t,b[++tott]=s[i].t+s[i].p;
	sort(b+1,b+tott+1);tott=unique(b+1,b+tott+1)-b-1;
	for(int i=1;i<=n;i++){
		int tmp=lower_bound(b+1,b+tott+1,s[i].t)-b;
		summ[tmp]+=1ll*s[i].f*(s[i].t+s[i].p);
		sumf[tmp]+=1ll*s[i].f;maxx=max(maxx,tmp);
		sump[tmp]+=1ll*s[i].f*s[i].p;
		int tp=upper_bound(b+1,b+tott+1,s[i].t+s[i].p)-b;d[tp]=max(d[tp],tmp);
	}
	for(int i=1;i<=tott;i++)summ[i]+=summ[i-1],sumf[i]+=sumf[i-1],sump[i]+=sump[i-1];
	for(int i=1;i<=tott;i++)dR[i]=min(i-1,maxx-1);
	for(int i=1;i<=tott;i++)dL[i]=max(dL[i-1],d[i]);
	dp[0]=0;T.Insert(1,0,tott,0,line(0LL,0LL));
	for(int i=1;i<=tott;i++){
		dp[i]=dp[i-1]-1ll*(b[i]-b[i-1])*x00+sump[i]-sump[i-1];
		LL tmpa=1ll*b[i]*x11-1ll*L*(x01+x10+x11+x11)+summ[i]-1ll*b[i]*sumf[i];
		LL tmpb=T.Query(1,0,tott,dL[i],dR[i],i);dp[i]=max(dp[i],tmpb+tmpa);
		T.Insert(1,0,tott,i,line(sumf[i],dp[i]-1ll*b[i]*x11-summ[i]));
		if(i>=maxx)ans=max(ans,dp[i]);
	}
	printf("%lld\n",ans);
	return 0;
}

谢谢！！！