题目
题目大意
给你一棵树，然后有一堆询问，每次给出两个点。
问所有点到两个点中最近点的距离的最大值。
正解
本来打了倍增，然后爆了，也懒得调……
显然可以在两个点之间的路径的中点处割开，一边归一个点管。
有个比较显然的思路是DP，设(f_x)表示(x)子树内的最远点，(g_x)向父亲那边走的最远点。
然后就可以倍增搞，合并一下……
代码复杂度极高。
然后有个简单又自然的思路是直接打(LCT)。直接把中间那条边断掉，然后求最远点即可。
想法倒是简单自然，接下来的问题就是，如何求最远点？
每条链可以维护子树到链顶的距离。设最远距离为(len)，则合并的时候，就是左区间的(len)、右区间的(len)加上左区间的(siz)加(1)、中间的答案（包括虚边转移过来的）加左区间的(siz)。这三个东西取最大值。
至于虚边信息，由于维护的是最大值，不能像和一样加加减减，所以要用multiset维护（或者手写数据结构也可以哈）。
然后你就会发现一个bug——翻转的时候怎么办？
(len)的计算是不满足交换律的，所以我们要维护一个(len2)，表示(len)反过来的样子。合并的时候跟上面相反就是了。换句话来说，就是在重链管的整棵子树中，到达链底的最远距离。
翻转的时候直接将两个交换就行了。
代码
using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#define N 100010
#define INF 1000000000
int n,m;
struct Node{
Node *fa,*c[2];
bool is_root,rev;
int siz,len1,len2,mx;
multiset<int> s;
inline void reverse(){
swap(c[0],c[1]);
swap(len1,len2);
rev^=1;
}
inline void pushdown(){
if (rev){
c[0]->reverse();
c[1]->reverse();
rev=0;
}
}
void push(){
if (!is_root)
fa->push();
pushdown();
}
inline void update(){
siz=c[0]->siz+c[1]->siz+1;
len1=max(max(c[0]->len1,c[0]->siz+1+c[1]->len1),c[0]->siz+mx+1);
len2=max(max(c[1]->len2,c[1]->siz+1+c[0]->len2),c[1]->siz+mx+1);
}
inline bool getson(){return fa->c[0]!=this;}
inline void rotate(){
Node *y=fa,*z=y->fa;
if (y->is_root){
is_root=1;
y->is_root=0;
}
else
z->c[y->getson()]=this;
int k=getson();
fa=z;
y->c[k]=c[k^1],c[k^1]->fa=y;
c[k^1]=y,y->fa=this;
siz=y->siz,len1=y->len1,len2=y->len2;
y->update();
}
inline void splay(){
push();
while (!is_root){
if (!fa->is_root){
if (getson()!=fa->getson())
rotate();
else
fa->rotate();
}
rotate();
}
}
} d[N],*null=d;
inline Node *access(Node *x){
Node *y=null;
for (;x!=null;y=x,x=x->fa){
x->splay();
if (x->c[1]!=null){
x->s.insert(x->c[1]->len1);
x->mx=max(x->mx,x->c[1]->len1);
}
x->c[1]->is_root=1;
x->c[1]=y;
y->is_root=0;
if (x->fa!=null){
x->fa->s.erase(x->fa->s.find(x->len1));
if (x->len1==x->fa->mx)
x->fa->mx=(x->fa->s.empty()?-INF:*x->fa->s.rbegin());
}
x->update();
}
return y;
}
inline Node *mroot(Node *x){
Node *t=access(x);
t->reverse();
return t;
}
inline void link(Node *u,Node *v){
mroot(u),u->splay();
Node *t=mroot(v);
t->fa=u;
u->s.insert(t->len1);
if (t->len1>u->mx){
u->mx=t->len1;
u->update();
}
}
Node *find(Node *t,int k){
t->pushdown();
if (k<=t->c[0]->siz)
return find(t->c[0],k);
if (k>t->c[0]->siz+1)
return find(t->c[1],k-t->c[0]->siz-1);
return t;
}
int main(){
scanf("%d",&n);
*null={null,null,null,0,0,0,-1,-1,-INF};
for (int i=1;i<=n;++i)
d[i]={null,null,null,1,0,1,0,0,-INF};
for (int i=1;i<n;++i){
int u,v;
scanf("%d%d",&u,&v);
link(&d[u],&d[v]);
}
scanf("%d",&m);
for (int i=1;i<=m;++i){
int u,v,l,ans=0;
scanf("%d%d",&u,&v);
mroot(&d[u]);
Node *a=access(&d[v]),*b;
a=find(a,a->siz>>1),a->splay();
for (b=a->c[1];b->c[0]!=null;b=b->c[0])
b->pushdown();
b->splay();
b->c[0]=null,b->update();
ans=max(a->len1,b->len2);
printf("%d
",ans);
b->c[0]=a,b->update();
}
return 0;
}
总结
如果要让(LCT)支持换根操作，并且维护的不满足交换律的东西的时候，要维护它的反向信息。