YbtOJ#752-最优分组【笛卡尔树,线段树】

1|0正题

题目链接:http://www.ybtoj.com.cn/problem/752

---

1|1题目大意

$n$个人，每个人有$c_i$和$d_i$分别表示这个人所在的队伍的最少/最多人数。

然后要求将这些人分成编号连续的若干队使得队伍最多，并且求分队方案数。

$1\leq n\leq 10^6$

---

1|2解题思路

阴间题目...

为了方便计算先定义一个结构体（包含答案和方案数）和加法运算表示取最大值/相同加方案数作为答案。

设$f_i$表示以第$i$个作为末尾的答案，首先$d_i$就相当于限制了一个后缀的范围，所以可以先用单调队列算出$left_i$表示根据$d$的限制从$i$能选到的最左位置$-1$。

然后$c_i$的限制很阴间，因为它的限制显然不是一个连续的范围。

考虑到一个$l\sim r$的转移的$c$限制只由这个区间最大的$c_i$来限制，所以可以考虑在笛卡尔树上做。这样其实加个数据结构可以轻松做到$O(n\log^2 n)$，但是这样过不了，还得优化。

分类讨论一下，我们现在考虑一个在右边的$i$和一个在左边的$j$，我们已经处理好了左边的答案，要用它来更新右边的。

1. $left_i<L$且$i< mid+c_{mid}$，此时可以先不管$left$了，只需要考虑后面那个，而且注意到每次$i$移动一格后$j$会多一个取值位置，所以我们维护一个记录区间最优答案的线段树。然后先用线段树查询出第一个满足条件的$i$的答案，然后后面每次加一个答案就好了
   然后这里一次的复杂度是左右区间的最小长度，和启发式合并类似时间复杂度$O(n\log n)$
2. $left_i<L$且$i\geq mid+c_{mid}$，此时对于所有的$i$，$j$的取值范围都是$[L,mid-1]$，直接拿线段树查出最大的答案，然后向右边区间修改就好了。
3. $L\leq left_i<mid$，这个好像只能对于每个$i$用线段树暴力查询。但是可以注意到，对于每个$i$从头到尾只会到一次这种情况，所以时间复杂度还是$O(n\log n)$的
4. $left_i\geq mid$，这个向右边分治的时候会解决，不需要这里统计

上面这四个情况的都是在一个区间里的，而且是按顺序出现的，需要注意的时候第二种情况是不能暴力枚举的，所以我们需要二分出这个情况区间的末尾

然后总共的时间复杂度就是$O(n\log n)$的了，细节有点多，比如建笛卡尔树的时候还要用$st$表查区间最大之类的。

---

1|3code

#pragma GCC optimize(2)
%:pragma GCC optimize(3)
%:pragma GCC optimize("Ofast")
%:pragma GCC optimize("inline")
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define ll long long
using namespace std;
const ll N=1e6+10,P=1e9+7,nul=-1e9+6;
struct node{
	ll f,g;
	node(ll ff=0,ll gg=0)
	{f=ff;g=gg;return;}
};
node operator+(node x,node y){
	if(x.f>y.f)return node(x.f,x.g);
	else if(x.f<y.f)return node(y.f,y.g);
	return node(x.f,(x.g+y.g)%P);
}
node plu(node x)
{return node(x.f+1,x.g);}
ll read() {
	ll x=0,f=1; char c=getchar();
	while(!isdigit(c)) {if(c=='-')f=-f;c=getchar();}
	while(isdigit(c)) x=(x<<1)+(x<<3)+c-48,c=getchar();
	return x*f;
}
ll n,c[N],d[N],left[N],st[N][20],lg[N];
deque<ll > q;node f[N];
struct SegTree{
	node w[N<<2],lazy[N<<2];
	void Downdata(ll x,ll L,ll R){
		if(lazy[x].f==nul)return;
		ll mid=(L+R)>>1;
		w[x*2]=w[x*2]+lazy[x];
		w[x*2+1]=w[x*2+1]+lazy[x]; 
		lazy[x*2]=lazy[x*2]+lazy[x];
		lazy[x*2+1]=lazy[x*2+1]+lazy[x];
		lazy[x].f=nul;return;
	}
	void Change(ll x,ll L,ll R,ll l,ll r,node p){
		if(l>r||l<0)return;
		if(L==l&&R==r){
			w[x]=w[x]+p;
			lazy[x]=lazy[x]+p;
			return;
		}
		ll mid=(L+R)>>1;Downdata(x,L,R);
		if(r<=mid)Change(x*2,L,mid,l,r,p);
		else if(l>mid)Change(x*2+1,mid+1,R,l,r,p);
		else Change(x*2,L,mid,l,mid,p),Change(x*2+1,mid+1,R,mid+1,r,p);
		w[x]=w[x*2]+w[x*2+1];
	}
	void Set(ll x,ll L,ll R,ll pos,node p){
		if(L==R){w[x]=p;return;}
		ll mid=(L+R)>>1;Downdata(x,L,R);
		if(pos<=mid)Set(x*2,L,mid,pos,p);
		else Set(x*2+1,mid+1,R,pos,p);
		w[x]=w[x*2]+w[x*2+1];
	}
	node Ask(ll x,ll L,ll R,ll l,ll r){
		if(l>r||l<0)return node(nul,nul);
		if(L==l&&R==r)return w[x];
		ll mid=(L+R)>>1;Downdata(x,L,R);
		if(r<=mid)return Ask(x*2,L,mid,l,r);
		if(l>mid)return Ask(x*2+1,mid+1,R,l,r);
		return Ask(x*2,L,mid,l,mid)+Ask(x*2+1,mid+1,R,mid+1,r);
	}
}T;
ll Ask(ll l,ll r){
	ll z=lg[r-l+1];
	ll x=st[l][z],y=st[r-(1<<z)+1][z];
	return (c[x]>=c[y])?x:y;
}
void solve(ll L,ll R){
	if(L==R){
		f[L]=f[L]+T.Ask(1,0,n,L,L);
		T.Set(1,0,n,L,f[L]);
		return;
	}
	ll x=Ask(L+1,R);
	solve(L,x-1);
	ll l=x,r=R;
	while(l<=r){
		ll mid=(l+r)>>1;
		if(left[mid]>=L)r=mid-1;
		else l=mid+1;
	}
	ll pos=r;
	l=max(x,L+c[x]);
	r=min(min(R,x+c[x]),pos);
	node tmp=T.Ask(1,0,n,L,l-c[x]);
	ll p=l-c[x]+1;
	for(ll i=l;i<=r;i++){
		f[i]=f[i]+plu(tmp);
		if(p<x)tmp=tmp+f[p],p++;
	}
	tmp=T.Ask(1,0,n,L,x-1);
	if(r+1>=x)T.Change(1,0,n,r+1,pos,plu(tmp));
	for(ll i=pos+1;i<=R;i++){
		if(left[i]>=x)break;
		tmp=T.Ask(1,0,n,left[i],min(i-c[x],x-1));
		f[i]=f[i]+plu(tmp);
	}
	
	solve(x,R);
	return;
}
signed main()
{
	freopen("schooldays.in","r",stdin);
	freopen("schooldays.out","w",stdout);
	n=read();
	for(ll i=1;i<=n;i++){
		c[i]=read();d[i]=read();
		ll &l=left[i];l=left[i-1];
		while(!q.empty()&&d[q.back()]>=d[i])
			q.pop_back();
		q.push_back(i);
		while(i-l>d[q.front()]){
			l++;
			if(q.front()==l)q.pop_front();
		}
		st[i][0]=i;
	}
	for(ll i=2;i<=n;i++)lg[i]=lg[i>>1]+1;
	for(ll j=1;(1<<j)<=n;j++)
		for(ll i=1;i+(1<<j)-1<=n;i++){
			ll x=st[i][j-1],y=st[i+(1<<j-1)][j-1];
			st[i][j]=(c[x]>=c[y])?x:y;
		}
	for(int i=0;i<(N<<2);i++)
		T.lazy[i]=node(nul,0),T.w[i]=node(-1e9,0);
	for(ll i=1;i<=n;i++)f[i]=node(nul,nul);
	f[0]=node(0,1);solve(0,n);
	if(f[n].f<=0)return 0&puts("-1");
	printf("%lld %lld\n",f[n].f,f[n].g);
	return 0;
}

__EOF__

本文作者：QuantAsk
本文链接：https://www.cnblogs.com/QuantAsk/p/14418159.html
关于博主：退役OIer，GD划水选手
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！