[LibreOJ #2341]【WC2018】即时战略【交互】【LCT】

Description

有一棵n个点的结构未知的树，初始时只有1号点是已被访问的。

你可以调用交互库的询问函数explore(x,y)，其中x是已访问的点，y是任意点。

它会返回x向y方向走第一步的点，如果该点未被访问，则将其标记为已访问。

你需要实现一个函数，它通过接口得到n和T，需要在T次explore操作内将所有的点标记（也就是说走完这棵树）。

要求最严格的两档数据：

n<=300000,T<=300020，且原树为一条链（1号点不一定是端点）。

n<=300000,T<=5000000

Solution

显然我们要将链的情况分开讨论

考虑这样一个做法，我们将编号随机排列，每次找到排列中第一个尚未被访问的点，从当前所在的链端开始explore，若走到的点是未访问的说明这个点就在这一侧，直接一直扩展到目标点。否则说明这个点在链的另一侧，跳到链的另一端一直扩展到目标点。

这样的出错（即链两边跳）的期望次数是\(\log n\)的

大概是因为每次期望都会消掉某一条链的一半这样。

考虑一棵树怎么做。

我们用一个LCT来维护已经扩展出来的树，将1作为根，每一次访问从1开始，在当前所在的prefer链上二分然后explore，若扩展出的点是未访问点则一直怼下去，否则就修改二分区间（实际上在splay上走），如果不在同一条prefer链上就跳到那一条去。

每次找到目标点就access

注意这里需要尽量保持splay的平衡，每次搞出新点都access一下。

具体可以看代码（有些地方可能比较谜，改一点就差很远）

均摊次数就是\(O(n\log n)\)的

Code

#include <bits/stdc++.h>
#include "rts.h"
#define fo(i,a,b) for(int i=a;i<=b;++i)
#define fod(i,a,b) for(int i=a;i>=b;--i)
#define N 300005
using namespace std;

int cnt;
bool bz[N];
namespace LCT
{
	int sz[N],r[N],f[N],fn[N],dep[N],t[N][2],li[N],ri[N];
	void up(int k)
	{
		sz[k]=sz[t[k][0]]+sz[t[k][1]]+1;
		li[k]=(t[k][0])?li[t[k][0]]:k;
		ri[k]=(t[k][1])?ri[t[k][1]]:k;
	}
	void hb(int p,int x,int y)
	{
		if(x&&p>=0) t[x][p]=y;
		if(y) fn[y]=p,f[y]=x;
	}
	void rot(int k)
	{
		int fa=f[k],p=fn[k];
		hb(p,fa,t[k][1-p]);
		hb(fn[fa],f[fa],k);
		hb(1-p,k,fa);
		up(fa),up(k);
	}
	int d[N];
	void splay(int k,int x)
	{
		while(f[k]!=x&&fn[k]!=-1&&f[k]!=0)
		{
			if(f[f[k]]==x||fn[f[k]]==-1||f[f[k]]==0) rot(k);
			else if(fn[k]==fn[f[k]]) rot(f[k]),rot(k);
			else rot(k),rot(k);
		}
		up(k);
	}
	void access(int k)
	{
		int r=k;
		splay(k,0);
		fn[t[k][1]]=-1,t[k][1]=0;
		up(k);
		while(f[k]!=0)
		{
			int fa=f[k];
			splay(fa,0);
			fn[t[fa][1]]=-1,hb(1,fa,k);
			up(fa),k=fa;
		}
		splay(r,0);
	}
	void link(int x,int y)
	{
		access(x);f[y]=x,fn[y]=-1,up(y);
	}
	void fd(int x,int y)
	{
		splay(x,0);
		while(x!=y)
		{
			cnt++;
			int p=explore(x,y);
			if(p==ri[t[x][0]]) x=t[x][0];
			else if(p==li[t[x][1]]) x=t[x][1];
			else
			{
				if(bz[p]) splay(p,0);
				else up(p),link(x,p),bz[p]=1;
				x=p;
			}
		}
		access(y);
	}
}
using namespace LCT;

int de[N];
void solve3(int n,int T)
{
	int x=1,y=1;
	int i=1;
	while(i<=n-1)
	{
		int w=explore(x,de[i]);
		if(bz[w]) swap(x,y),w=explore(x,de[i]),cnt++;
		bz[w]=1;
		while(w!=de[i]) w=explore(w,de[i]),bz[w]=1,cnt++;
		x=w;
		while(i<=n-1&&bz[de[i]]) i++;
	}
}

void play(int n, int T, int dataType)
{
	memset(bz,0,sizeof(bz));
	bz[1]=sz[1]=dep[1]=1;
	up(1);
	fo(i,2,n) de[i-1]=i,sz[i]=1;
	random_shuffle(de+1,de+n);
	if(dataType==3) {solve3(n,T);return;}
	int i=1,w=1;
	while(i<=n-1)
	{
		fd(1,de[i]);
		while(i<=n-1&&bz[de[i]]) i++;
	}
	n++,n--;
}