【UOJ#410】[IOI2018]会议

题目链接

题意

给出一个长度为 $n$ 的序列。
$Q$ 次询问区间 $[l,r]$ , 求出最小代价 , 代价为 在 $[l,r]$ 中选出一个点 , 区间内每个点与这个点之间(包括端点)的最大值之和。

Sol

首先可以考虑 $O(n^2)dp$
设 $f[l][r]$ 表示 $[l,r]$ 的答案 , 那么考虑转移。
贡献和最大值相关 , 我们考虑 $[l,r]$ 之间的最大值点 $p$ , 显然经过这个点的贡献都是$H[p]$ ,$H[p]$ 是位置 $p$ 上的数。
很简单得到以下转移式:
$$f[l][r]=min\{f[l][p-1]+(r-p+1)\ast H[p],f[p+1][r]+(p-l+1)\ast H[p]\}$$
考虑选出的点在最大值点的左侧还是右侧即可。

写完 $O(n^2)$ 后 , 显然的我们不能在状态和转移上优化了 , 首先状态$O(n^2)$没法变 , 转移是 $O(1)$ 的也优化不了。
但是我们可以依据要询问的区间来减少掉一些无用状态的计算。
对于询问 $[l,r]$ 它的转移只和 $f[l][p-1],f[p+1][r]$ 有关, 而这些一定都是以一个最大值点作为左端点或者右端点的 , 所以我们先询问离线挂在其区间的最大值点上,然后最大值分治(也是构建笛卡尔树) , 假设当前区间为 $[l,r]$ ,最大值点为 $p$ , 那么只需要求解出 $f[p+1][(p+1)...r],f[l...(p-1)][p-1]$ , 这样当前区间的答案都能算了 , 算完答案之后更新dp值即可。
怎么更新?
首先维护两个线段树 , 分别维护固定了左端点,右端点为当前区间的左右时其他地方的dp值。
那么当分治到 $[l,r]$ 时 , 固定左端点的线段树维护的其实是 $f[l][l...(p-1)]$ , 固定右端点的维护的是 $f[l...(p-1)][p-1]$ , 因为我们是从下往上合并的。
考虑原来的转移式子对于固定左端点的更新(右端点一样的做法) , 要求$f[l][i]$ , 首先当$i<p$ 时从左边上来的时候已知 , 那么只要考虑 $i>p$ , 考虑 $i$ 的移动最两个取min的东西的影响。

$f[l][i]=min\{f[l][p-1]+(i-p+1)\ast H[p],f[p+1][i]+(p-l+1)\ast H[p]\}$

$i$ 往右边移动一个位置 , 左边的式子增长量为 $H[p]$ , 右边的式子增长量显然最坏情况下也不会超过 $H[p]$。
那么转移就是具有单调性的 , 一段是前一个 , 一段是后一个。
那么如果线段树上维护当前区间左右端点的 $f$ 用于比较 , 那么就变成了区间一次函数覆盖和区间的加法 , 因为后面的式子中 $f[p+1][i]$ 已经在原来的固定左端点的线段树中了,只需要加法。

那么就这样用线段树维护 dp 值就行了。

(这种与区间最值相关的转移不妨多往最值分治方向上想想)

code:

#include "meetings.h"
#include
using namespace std;
typedef long long ll;
namespace WP{
	const int N=7.5e5+10;
	int H[N],Qnum;ll ans[N];
	struct Qry{int l,r;}Q[N];
	int Id[20][N],log[N];
	typedef vector<int> Vi;
	Vi Que[N];
	const ll INF=1e18;
	int n;
	inline ll F(ll k,ll b,ll x){return k*x+b;}
#define ls (u<<1)
#define rs (u<<1|1)
	struct Seg{
		ll vall[N<<2],valr[N<<2],tagK[N<<2],tagB[N<<2],add[N<<2];
		bool tag[N<<2];
		inline void Cover(int u,int l,int r,ll k,ll b) {
			tag[u]=1;tagK[u]=k,tagB[u]=b,add[u]=0;
			vall[u]=F(k,b,l),valr[u]=F(k,b,r);
			return;
		}
		inline void Add(int u,ll x){add[u]+=x,vall[u]+=x,valr[u]+=x;return;}
		inline void push_down(int u,int l,int r){
			if(tag[u]) {
				int mid=l+r>>1;
				Cover(ls,l,mid,tagK[u],tagB[u]);
				Cover(rs,mid+1,r,tagK[u],tagB[u]);
				tag[u]=0;
			}
			if(add[u]) {Add(ls,add[u]);Add(rs,add[u]);add[u]=0;}
			return;
		}
		void Query(int u,int l,int r,int p,ll&ans){
			if(l==r) {ans=min(ans,vall[u]);return;}
			push_down(u,l,r);int mid=l+r>>1;
			if(mid>=p) Query(ls,l,mid,p,ans);else Query(rs,mid+1,r,p,ans);
		}
		void Modify(int u,int l,int r,int L,int R,ll k,ll b,ll v){
			if(L>R) return;
			if(l>=L&&r<=R) {
				if(vall[u]+v>=F(k,b,l)&&valr[u]+v>=F(k,b,r)) return Cover(u,l,r,k,b);//trans 1
				if(vall[u]+v<=F(k,b,l)&&valr[u]+v<=F(k,b,r)) return Add(u,v);//trans 2
			}
			int mid=l+r>>1;push_down(u,l,r);
			if(mid>=L) Modify(ls,l,mid,L,R,k,b,v);
			if(mid< R) Modify(rs,mid+1,r,L,R,k,b,v);
			vall[u]=vall[ls],valr[u]=valr[rs];
			return;
		}
	}fixl,fixr;
	inline int CK(int i,int j) {if(!i) return j;if(!j) return i;return H[i]>H[j]? i:j;}
	inline int Get(int l,int r){
		if(l==r) return l;int D=log[r-l+1]-1;
		return CK(Id[D][l],Id[D][r-(1<<D)+1]);
	}
	ll Divide(int l,int r){
		if(l>r) return 0;
		int p=Get(l,r);
		ll fl,fr;
		fl=Divide(l,p-1);fr=Divide(p+1,r);
		int sz=Que[p].size();
		for(int i=0;i<sz;++i) {
			int l=Q[Que[p][i]].l,r=Q[Que[p][i]].r,id=Que[p][i];
			ans[id]=(ll)H[p]*(r-l+1);
			if(l<p) {ll ret=INF;fixr.Query(1,1,n,l,ret);ans[id]=min(ans[id],(ll)(r-p+1)*H[p]+ret);}//此时固定右端点 , 当询问小于 p 的地方的时候右端点就是 p-1
			if(r>p) {ll ret=INF;fixl.Query(1,1,n,r,ret);ans[id]=min(ans[id],(ll)(p-l+1)*H[p]+ret);}
		}
		fl=(ll)(p-l)*fl;
		fr=(ll)(r-p)*fr;
		if(p>l) fixr.Query(1,1,n,l,fl);
		if(p<r) fixl.Query(1,1,n,r,fr);
		fixl.Modify(1,1,n,p,r,H[p],fl+(ll)(-p+1)*H[p],(ll)(p-l+1)*H[p]);
		fixr.Modify(1,1,n,l,p,-H[p],fr+(ll)(p+1)*H[p],(ll)(r-p+1)*H[p]);
		return H[p];
	}
	inline void init(Vi h,Vi L,Vi R) {
		n=h.size();Qnum=L.size();
		for(int i=1;i<=n;++i) {H[i]=h[i-1],Id[0][i]=i;if((1<<log[i-1])<i) log[i]=log[i-1]+1;else log[i]=log[i-1];}
		for(int i=1;i<=Qnum;++i) Q[i].l=L[i-1]+1,Q[i].r=R[i-1]+1;
		for(int k=1;k<=log[n];++k)
			for(int i=1;i+(1<<k)-1<=n;++i)
				Id[k][i]=CK(Id[k-1][i],Id[k-1][i+(1<<k-1)]);
		for(int i=1;i<=Qnum;++i) {
			int pos=Get(Q[i].l,Q[i].r);
			Que[pos].push_back(i);
		}
		Divide(1,n);
		return;
	}
}

std::vector<long long> minimum_costs(std::vector<int> H, std::vector<int> L,std::vector<int> R) {
	WP::init(H,L,R);int Q=L.size();vector<ll> ans(Q);
	for(int i=0;i<Q;++i) ans[i]=WP::ans[i+1];
	return ans;
}