「雅礼集训 2017 Day5」远行

题目链接

问题分析

要求树上最远距离，很显然就想到了树的直径。关于树的直径，有下面几个结论：

• 如果一棵树的直径两个端点为\(a,b\)，那么树上一个点\(v\)开始的最长路径是\(v\rightarrow a\)或\(v \rightarrow b\)。
• 如果有两棵树，直径分别为\(a_1,b_1\)和\(a_2,b_2\)，那么在这两棵树间连一条边，新树的直径只可能是\(a_1\rightarrow b_1,a_1\rightarrow a_2, a_1\rightarrow b_2, a_2\rightarrow a_1, a_2 \rightarrow b_1, a_2 \rightarrow b_2\)这\(6\)种可能。

那么这道题就是用并查集维护每棵树的直径的两端，然后用LCT维护树的形态即可。如果需要树的直径性质的证明，可以在下方留言。

参考程序

#include <bits/stdc++.h>
using namespace std;

const int Maxn = 300010;
int Father[ Maxn ], Child[ Maxn ][ 2 ], Stack[ Maxn ], Tag[ Maxn ];
int Size[ Maxn ];
int N, Q, Rec[ Maxn ][ 2 ], Fa[ Maxn ], Type;

void Collect( int Ind ) {
	Size[ Ind ] = Size[ Child[ Ind ][ 0 ] ] + Size[ Child[ Ind ][ 1 ] ] + 1;
	return;
}
void TagOn( int Ind ) {
	Tag[ Ind ] ^= 1;
	swap( Child[ Ind ][ 0 ], Child[ Ind ][ 1 ] );
	return;
}
void TagDown( int Ind ) {
	if( Tag[ Ind ] ) {
		TagOn( Child[ Ind ][ 0 ] );
		TagOn( Child[ Ind ][ 1 ] );
		Tag[ Ind ] ^= 1;
	}
	return;
}
bool IsRoot( int Ind ) {
	if( Ind == 0 ) return true;
	return !( ( Child[ Father[ Ind ] ][ 0 ] == Ind ) || ( Child[ Father[ Ind ] ][ 1 ] == Ind ) );
}
void Rotate( int C ) {
	int B = Father[ C ];
	int A = Father[ B ];
	int Tag = Child[ B ][ 1 ] == C;
	if( !IsRoot( B ) ) Child[ A ][ Child[ A ][ 1 ] == B ] = C;
	Father[ C ] = A;
	Child[ B ][ Tag ] = Child[ C ][ Tag ^ 1 ];
	Father[ Child[ C ][ Tag ^ 1 ] ] = B;
	Child[ C ][ Tag ^ 1 ] = B;
	Father[ B ] = C;
	Collect( B ); Collect( C );
	return;
}
void Splay( int Ind ) {
	if( Ind == 0 ) return;
	int Num = 0; Stack[ ++Num ] = Ind; int Temp = Ind;
	while( !IsRoot( Temp ) ) {
		Temp = Father[ Temp ];
		Stack[ ++Num ]  = Temp;
	}
	for( int i = Num; i >= 1; --i ) TagDown( Stack[ i ] );
	while( !IsRoot( Ind ) ) {
		int X = Father[ Ind ];
		int Y = Father[ X ];
		if( !IsRoot( X ) )
			if( ( Child[ Y ][ 0 ] == X ) ^ ( Child[ X ][ 0 ] == Ind ) )
				Rotate( Ind );
			else
				Rotate( X );
		Rotate( Ind );
	}
	Collect( Ind );
	return;
}
void Access( int Ind ) {
	for( int i = 0; Ind; i = Ind, Ind = Father[ Ind ] ) {
		Splay( Ind ); Child[ Ind ][ 1 ] = i; Collect( Ind );
	}
	return;
}
void MakeRoot( int Ind ) {
	Access( Ind );
	Splay( Ind );
	TagOn( Ind );
	return;
}
int FindRoot( int Ind ) {
	Access( Ind ); Splay( Ind );TagDown( Ind );
	while( Child[ Ind ][ 0 ] ) {
		Ind = Child[ Ind ][ 0 ]; TagDown( Ind );
	}
	Splay( Ind );
	return Ind;
}
void Split( int x, int y ) {
	MakeRoot( x );
	Access( y );
	Splay( y );
	return;
}
void Link( int x, int y ) {
	MakeRoot( x );
	if( FindRoot( y ) == x ) return;
	Father[ x ] = y;
	return;
}
void Cut( int x, int y ) {
	MakeRoot( x );
	if( FindRoot( y ) != x || Child[ y ][ 0 ] || Father[ y ] != x ) return;
	Father[ y ] = Child[ x ][ 1 ] = 0;
	Collect( x );
	return;
}

int GetFather( int x ) {
	if( Fa[ x ] == x ) return x;
	Fa[ x ] = GetFather( Fa[ x ] );
	return Fa[ x ];
}

int main() {
	scanf( "%d", &Type );
	scanf( "%d%d", &N, &Q );
	for( int i = 1; i <= N; ++i ) {
		Fa[ i ] = i;
		Size[ i ] = 1;
		Rec[ i ][ 0 ] = Rec[ i ][ 1 ] = i;
	}
	int LastAns = 0;
	for( int i = 1; i <= Q; ++i ) {
		int Opt; scanf( "%d", &Opt );
		if( Opt == 1 ) {
			int u, v; scanf( "%d%d", &u, &v );
			if( Type ) u ^= LastAns, v ^= LastAns;
			int U = GetFather( u ), V = GetFather( v );
			if( U == V ) continue;

			int Max = 0, x, y;
			Split( Rec[ U ][ 0 ], Rec[ U ][ 1 ] );
			if( Size[ Rec[ U ][ 1 ] ] > Max ) {
				Max = Size[ Rec[ U ][ 1 ] ];
				x = Rec[ U ][ 0 ]; y = Rec[ U ][ 1 ];
			}
			Split( Rec[ V ][ 0 ], Rec[ V ][ 1 ] );
			if( Size[ Rec[ V ][ 1 ] ] > Max ) {
				Max = Size[ Rec[ V ][ 1 ] ];
				x = Rec[ V ][ 0 ]; y = Rec[ V ][ 1 ];
			}
			Link( u, v ); Fa[ U ] = V;
			for( int j = 0; j < 2; ++j )
				for( int k = 0; k < 2; ++k ) {
					Split( Rec[ U ][ j ], Rec[ V ][ k ] );
					if( Size[ Rec[ V ][ k ] ] > Max ) {
						Max = Size[ Rec[ V ][ k ] ];
						x = Rec[ U ][ j ]; y = Rec[ V ][ k ];
					}
				}
			Rec[ V ][ 0 ] = x; Rec[ V ][ 1 ] = y;
		} else {
			int u; scanf( "%d", &u );
			if( Type ) u ^= LastAns;
			int U = GetFather( u );
			LastAns = 0;
			for( int j = 0; j < 2; ++j ) {
				Split( Rec[ U ][ j ], u );
				LastAns = max( LastAns, Size[ u ] );
			}
			--LastAns;
			printf( "%d\n", LastAns );
			fflush( stdout );
		}
	}
	return 0;
}