析合树

前言

A组的题实在是太与时俱进了……

简介

这是LCAdalao在今年的WC上提出来的算法（也是数据结构），用途是维护一类关于连续段的计数问题。

连续段

先给出几个定义：
序列：(1sim n)的有序集合
段：序列上的一个闭区间([l,r])
置换（排列）：一个双射(P:A o A,A_i o A_{P_i})
不动点（连续段）：对于排列(P)，定义连续段((P,[l,r]))表示一个段，要求(P_{lsim r})值域是连续的。形式化地说，对于排列(P)，连续段是一个段(Q)满足(Qin I∧P[Q]in I)。在以后的叙述中，我们用(I_P)表示所有连续段的集合。一个连续段的值域(ran(S)=[min_{iin S}P_i,max_{iin S}P_i])。

性质

连续段有很多~~可以用显然法证明的~~优美的性质。
两个连续段的交、两个相交连续段的并都是连续段。
如果我们想存储所有的连续段，那么一个可以被另两个连续段的交/并表示出来的连续段显然是废的。这样的话，我们可以定义本原连续段(M)表示一个连续段，满足在(I_P)中，不存在与(M)相交且互不包含的连续段。
那又有一个性质：一个连续段可以由几个本原连续段构成。这样一来，本原连续段的集合(M_P)就是(I_P)的一个极小基（即不存在比它更小却能表示出(I_P)的集合）。

析合树

终于说到析合树了。
事实上，我们可以把(I_P)映射到一棵有根树上，并且这个映射是一个双射，我们称这棵有根树为析合树。具体地说，析合树的每个节点表示一个本原连续段，点(i)是点(j)的祖先当且仅当段(M_jsubsetneq)段(M_i)。该树的每个节点分为析点和合点两种：
析点：将所有子节点的值域区间离散化形成一个区间（暂且称之为儿子排列），儿子排列中的每一个非平凡区间（即1<长度<子节点个数），均不是连续段。
合点：……，均是连续段。
盗张图来表示一下。
析点和合点也有一些显然的性质：对于非叶节点，合点至少有两个儿子，析点至少有四个……

构造

这里我讲的是一种(O(n))的增量法。
假设现在已经搞定了[1…i-1]的析和森林，我们把每个析合树的root拿出来放到一个栈里（代表区间后的在栈顶）。现在，要加入第i个位置，先建一个析点就表示这个位置，设为x。
考虑如何加入一个点。

设要加入的点是x，栈顶的点是y。
有三种情况：

y是一个合点，x能成为y新的儿子（即(ran(y的最后一个儿子))和(ran(x))连接起来是连续段），拿y递归加入。
若1不可，而y和x能成为兄弟（即(ran(y))和(ran(x))连接起来是连续段），新生成一个点z，作为y和x共有合点父亲，拿z递归加入。
若1、2都不可，新生成一个点z，作为x和栈顶的若干点（尽量少）的共有析点父亲，拿z递归加入。
若1、2、3都不可，说明不能再合并什么的了，直接把x加入栈顶。

情况1、2、4都很简单，关键就在于处理情况3。

由于情况3是生成一个析点z，故其任意两个相邻儿子的值域区间都不能连起来；而我们又要保证z代表了一个连续段。
设我们现在加入的点x表示的区间是([x_x,y])，则点z的区间是([x_z,y])。我们求出(a_iin ran(z))的(i)的最小值(l)和最大值(r)，这能形成一个区间([l,r])。显然，当(r>y)时，不论我们怎么扩展(x_z)，z都不可能是一个连续段；那这样一来，只有当(r≤y)并且点z尚不为连续段时，我们才合并栈顶。
具体实现时，我们可以先通过RMQ、线段树之类的东西预处理每个区间([i,i+1])所对应的([l,r])，然后对于每个点x（设它表示区间([i,j])）额外记录两个区间([l_c,r_c])、([l_d,r_d])分别表示区间([i,j+1])、区间([i,j])各自对应的([l,r])。这个可以由我们预处理出的东西合并得来。

但是上述做法在最坏情况下要遍历整个栈，渐进复杂度是(O(n^2))的。
考虑优化。我们可以给每个通过操作4压入栈的点维护一个类似fail指针：(L_i)表示从(i)出发直接和间接地向左最远能到达的位置（即满足((L_i,i])是一个连续段的最小的数）。那显然就是进行操作3尝试合并失败，第一次(r>y)时的栈顶值。当然，除了这个，我们还要将构造不成功的点z记录下来。
这样一来，我们处理情况3时，就不用遍历栈，而是可以沿着栈顶的fail链跑，每次把将被合并的点改为当时的z。因为((L_i,i])都是左开右闭的区间，并起来还是左开右闭的区间，故正确性十分显然。
然后又由于走过的(L_i)不会再走了，故而构造的时间复杂度是(O(n))的。

板题

GMOJ6202=GMOJ6279
这两道题都是求包含询问区间的最小连续段，那么就是在析合树上找LCA，假如找到的是析点则直接取析点；不然的话，要从合点LCA下移一步走到两个点，然后取两个点的并（因为合点可能包括了其他不在询问范围内的本原连续段）。

Code

#include <cstdio>
#include <algorithm>
#define A v*2
#define B A+1
#define min(x,y) (x<y?x:y)
#define max(x,y) (x>y?x:y)
#define MIN(x,y) if(x>y)x=y
#define MAX(x,y) if(x<y)x=y
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;

const int N=233333;
int n,a[N],pos[N],t0[N*4],t1[N*4],pl,pr,id[N];

void bt(int v,int l,int r)
{
	if(l==r) {t0[v]=t1[v]=pos[l]; return;}
	int m=l+r>>1;
	bt(A,l,m), bt(B,m+1,r);
	t0[v]=min(t0[A],t0[B]);
	t1[v]=max(t1[A],t1[B]);
}

struct P
{
	int x,y;
	inline P(){x=N,y=0;}
	inline P(int _x,int _y){x=_x,y=_y;}
};
inline void uni(P&a,const P&b) {MIN(a.x,b.x); MAX(a.y,b.y);}
struct nod
{
	bool dv;
	int ls;
	P a,b,c,d;
}b[N]; int b0;
void ft(int v,int l,int r)
{
	if(pr< l||r< pl) return;
	if(pl<=l&&r<=pr) {MIN(b[b0].c.x,t0[v]); MAX(b[b0].c.y,t1[v]); return;}
	int m=l+r>>1;
	ft(A,l,m), ft(B,m+1,r);
}

inline bool ck(nod a) {return a.a.y-a.a.x==a.b.y-a.b.x;}
inline nod uni(nod a,nod b) 
{
	uni(a.a,b.a), uni(a.b,b.b);
	a.d=a.c, uni(a.d,b.d);
	uni(a.c,b.c);
	return a;
}
int z[N],z0,f[N][17],r[N],q0,q[N],dep[N];
struct fail{int x; nod a;}d[N];
int add(int x)
{
	if(!z0) {z[++z0]=x; return 0;}
	int y=z[z0];
	if(!b[y].dv&&ck(uni(b[b[y].ls],b[x])))
	{
		b[y]=uni(b[y],b[x]), z0--;
		return f[b[y].ls=x][0]=y;
	}
	if(ck(uni(b[y],b[x])))
	{
		b[++b0]=uni(b[y],b[x]), z0--;
		b[b0].ls=x, b[b0].dv=0;
		return f[y][0]=f[x][0]=b0;
	}
	int t=z0;
	nod e=uni(b[y],b[x]);
	for(; e.d.y<=b[x].a.y&&!ck(e); t=d[t].x) e=uni(d[t].a,e);
	if(ck(e))
	{
		b[++b0]=e, b[b0].dv=1, b[b0].ls=z[++z0]=x;
		fo(i,t,z0) f[z[i]][0]=b0;
		z0=t-1;
		return b0;
	}
	z[++z0]=x;
	d[z0]=(fail){t,e};
	return 0;
}

int lca(int x,int y)
{
	if(dep[x]<dep[y]) swap(x,y);
	fd(i,16,0) if(dep[f[x][i]]>=dep[y]) x=f[x][i];
	if(x==y) return x;
	fd(i,16,0) if(f[x][i]^f[y][i]) x=f[x][i],y=f[y][i];
	return f[x][0];
}

int go(int x,int y)
{
	fd(i,16,0) if(dep[f[y][i]]>dep[x]) y=f[y][i];
	return y;
}

int m,x,y;
int main()
{
	freopen("sequence.in","r",stdin);
	freopen("sequence.out","w",stdout);
	scanf("%d",&n);
	fo(i,1,n) scanf("%d",&a[i]), pos[a[i]]=i;
	bt(1,1,n);
	fo(i,1,n)
	{
		b[id[i]=++b0].dv=1;
		b[b0].a=P(i,i);
		b[b0].b=P(a[i],a[i]);
		b[b0].c=b[b0].d=P();
		if(i<n)
		{
			pl=a[i], pr=a[i+1];
			if(pl>pr) swap(pl,pr);
			ft(1,1,n);
		}
		for(x=b0; x; x=add(x));
	}
	fo(i,1,b0) r[f[i][0]]++;
	fo(i,1,b0) if(!r[i]) q[++q0]=i;
	fo(i,1,q0)
	{
		x=q[i];
		if(f[x][0]&&!--r[f[x][0]]) q[++q0]=f[x][0];
	}
	fd(i,q0,1)
	{
		x=q[i];
		dep[x]=dep[f[x][0]]+1;
		fo(j,1,16) f[x][j]=f[f[x][j-1]][j-1];
	}
	for(scanf("%d",&m); m--;)
	{
		scanf("%d%d",&x,&y);
		int z=lca(id[x],id[y]);
		nod w=b[z].dv ? b[z] : uni(b[go(z,id[x])],b[go(z,id[y])]);
		printf("%d %d
",w.a.x,w.a.y);
	}
}

参考资料

简单的连续段数据结构by LCAdalao
析合树学习小记by cc
析合树 - OI Wiki