树的直径，LCA复习笔记

前言

复习笔记第6篇。

求直径的两种方法

树形DP：

dfs(y); ans=max( ans,d[x]+d[y]+w[i] ); d[x]=max( d[x],d[y]+w[i] );

               int dis=dfs( v,u )+1;
                if ( f[u]<dis ) g[u]=f[u],f[u]=dis;
                else if ( g[u]<dis ) g[u]=dis;
        ans=max( ans,f[u]+g[u]+1 );
        return f[u];

两次 bfs/dfs:

从任意点出发，找到最远点l;

从 l 出发，找到最远点 r. \(l\to r\) 即为所求。

0——P4408 [NOI2003]逃学的小孩

link

题意

\(n\) 点 \(m\) 边的带权无向图，任意两点之间有且仅有一条通路。有三个点：A，B，C，从 C 出发，先去 AB 中较近的一个，如果没找到，再去另一个，不给出具体的 ABC，问最坏情况下要多长时间。

思路

题目要求就是在一棵树上找到3个点 \(A\) 、\(B\)、\(C\) 令 \(AB+BC\) 最大，同时要满足 \(AC>AB\)。

由于要最大化这个距离，一个很明显的想法就是让其中一条成为直径，设为 \(AB.\) 然后再找另一条 \(BC\) 即可。但是要满足 \(AC>AB\) ，所以就是：先找直径 \(AB\) ，然后找一点 \(C\) 使得 \(min(AC,BC)\) 取得最大值，\(ans=\) 直径 \(+min(AC,BC)=\) 直径 \(+BC.\)

代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=2e5+10;
struct edge
{
	int to,nxt;ll val;
}e[N*10];
int n,m,head[N],tot=0,vis[N];
ll dis[N],dis2[N];

void add( int u,int v,ll w )
{
	tot++; e[tot].to=v; e[tot].nxt=head[u]; e[tot].val=w; head[u]=tot;
}

int bfs( int S )
{
	memset( dis,0,sizeof(dis) ); memset( vis,0,sizeof(vis) );
	queue<int> q;
	while ( !q.empty() ) q.pop();
	q.push( S ); vis[S]=1; int res=0,num=0;
	while ( q.size() )
	{
		int u=q.front(); q.pop();
		for ( int i=head[u]; i; i=e[i].nxt )
		{
			int v=e[i].to;
			if ( vis[v] ) continue;
			vis[v]=1; dis[v]=dis[u]+e[i].val; q.push( v );
			if ( dis[v]>res ) res=dis[v],num=v;
		}
	}
	return num;
}

int main()
{
	scanf( "%d%d",&n,&m );
	for ( int i=1; i<=m; i++ )
	{
		int u,v; ll w; scanf( "%d%d%lld",&u,&v,&w );
		add( u,v,w ); add( v,u,w );
	}

	int l=bfs(1),r=bfs(l); ll ans=dis[r],res=0;
	for ( int i=1; i<=n; i++ )
		dis2[i]=dis[i];
	bfs( r );
	for ( int i=1; i<=n; i++ )
		res=max( res,min(dis[i],dis2[i]) );

	printf( "%lld",ans+res );
}

1——P2491 [SDOI2011]消防

link

题意

\(n\) 个城市，任意两个都连通且有唯一路径，每条连通两个城市的道路的长度为 \(z_i\). 在一条边长度和不超过 \(s\) 的路径（两端都是城市）上建立消防枢纽，要求其他所有城市到这条路径的距离的最大值最小。求枢纽位置。

思路

每一个点到树上最远的点一定在直径上.所以可以直接枚举直径上的点,然后在找直径上的点到其他点的距离最大是多少.一个很显然的想法是，在直径上取的距离越大越优，那么可以直接枚举起点。

但是 \(N^2\) 复杂度还是不够。显然，答案具有单调性（不超过 s 的情况下越长越好），那么可以通过双指针，单调队列优化，\(O(n)\) 实现这个过程。当然也可以二分不过要带一个 \(\log.\)

代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=3e5+10;
const ll inf=1e15+10;
struct edge
{
        ll fro,to,nxt; ll val;
}e[N<<1];
ll n,s,tot,head[N],dis[N],pre[N],bet[N],l,r;
ll ans=inf,sum[N],dis1[N],que[N]={inf},t=0,h=0;

void add( ll u,ll v,ll w )
{
        e[++tot].fro=u; e[tot].to=v; e[tot].val=w; e[tot].nxt=head[u]; head[u]=tot;
}

void dfs( ll u,ll fa,ll sum,bool sav )
{
        if ( sav ) pre[u]=fa,bet[u]=sum;
        dis[u]=dis[fa]+sum;
        for ( ll i=head[u]; i; i=e[i].nxt )
                if ( e[i].to!=fa ) dfs( e[i].to,u,e[i].val,sav );
}

void get_path()
{
        dfs( 1,0,0ll,0 ); ll mx=0;
        for ( ll i=1; i<=n; i++ )
                if ( dis[i]>mx ) l=i,mx=dis[i];
        dfs( l,0,0ll,1 ); mx=0;
        for ( ll i=1; i<=n; i++ )
                if ( dis[i]>mx ) r=i,mx=dis[i];
}

void bfs()
{
        memset( dis,63,sizeof(dis) ); queue<ll> q,fro;
        for ( ll i=r; i; i=pre[i] )
                q.push(i),fro.push(i),dis[i]=0;
        while ( !q.empty() )
        {
                ll v=q.front(),u=fro.front(); q.pop(); fro.pop();
                for ( ll i=head[v]; i; i=e[i].nxt )
                        if ( dis[e[i].to]>=inf )
                        {
                                dis[e[i].to]=dis[v]+e[i].val;
                                dis1[u]=max( dis1[u],dis[e[i].to] );
                                q.push( e[i].to ); fro.push( u );
                        }
        }
}

int main()
{
        scanf( "%lld%lld",&n,&s );
        for ( ll i=1,u,v,w; i<n; i++ )
                scanf( "%lld%lld%lld",&u,&v,&w ),add( u,v,w ),add( v,u,w );

        get_path(); bfs();
        pre[n+1]=r;
        for ( ll i=n+1; i; i=pre[i] )
                sum[pre[i]]=sum[i]+bet[i];
        for ( ll L=r,R=r; L && R!=l; L=pre[L] )
        {
                ll las=R; h++;
                while ( sum[R]-sum[L]<=s && R )
                {
                        las=R; R=pre[R];
                        if ( R && sum[R]-sum[L]<=s )
                        {
                                while ( dis1[R]>=que[t] && t>=h ) t--;
                                que[++t]=dis1[R];
                        }
                }
                if ( R==0 || sum[R]-sum[L]>s ) R=las;
                ll tmp=max( sum[L],sum[l]-sum[R] ); tmp=max( tmp,que[h] );
                ans=min( tmp,ans );
        }

        printf( "%lld",ans );

        return 0;
}

2——P2610 [ZJOI2012]旅游

link

题意

T国的国土可以用一个凸N边形来表示，包含 \(N-2\) 个城市，每个城市都是顶点为 \(N\) 边形顶点的三角形，两人的旅游路线可以看做是连接N个顶点中不相邻两点的线段。问一路能经过最多多少城市。

一个城市被当做经过当且仅当其与线路有至少两个公共点。

思路

很巧妙的一道题。（不愧是ZJOI）

三角剖分是个很有意思的信息。不是让你想递推啊喂

考虑什么样的城市是不满足三角剖分的。会发现，不可能存在一些城市围成一圈（这样有一个点就会在内部而不是端点），所以如果将相邻的城市连边，是不可能存在环的。没有环，又是连通的，那么就是树了。

问题就转化成了求树的直径，裸题。

然而事实上，建图有亿点麻烦...但是非常幸运的是，由于这道题是三角形，所以肯定是二叉树，那么我们有pair！我们有 map！我们有STL！重点是我们有O2！

于是这道题就做完了。

代码

#include <bits/stdc++.h>
using namespace std;
const int N=2e5+10;
struct edge
{
        int to,nxt;
}e[N<<1];
int head[N],tot=0,n,s[N][3],ans,g[N],f[N];
map<pair<int,int>,int> mp;

void add( int u,int v )
{
        e[++tot].to=v; e[tot].nxt=head[u]; head[u]=tot;
        e[++tot].to=u; e[tot].nxt=head[v]; head[v]=tot;
}

int dfs( int u,int fa )
{
        for ( int i=head[u]; i; i=e[i].nxt )
        {
                int v=e[i].to;
                if ( v==fa ) continue;
                int dis=dfs( v,u )+1;
                if ( f[u]<dis ) g[u]=f[u],f[u]=dis;
                else if ( g[u]<dis ) g[u]=dis;
        }
        ans=max( ans,f[u]+g[u]+1 );
        return f[u];
}

void build( int i,int j,int u )
{
        pair<int,int> pr=make_pair( i,j );
        if ( mp[pr] ) add( u,mp[pr] );
        else mp[pr]=u;
}

int main()
{
        scanf( "%d",&n );
        for ( int i=1; i<=n-2; i++ )
        {
                scanf( "%d%d%d",&s[i][0],&s[i][1],&s[i][2] ); sort( s[i],s[i]+3 );
                build( s[i][0],s[i][1],i ); build( s[i][1],s[i][2],i ); build( s[i][0],s[i][2],i );
        }

        dfs( 1,0 );
        printf( "%d",ans );

        return 0;
}

3——P3629 [APIO2010]巡逻

link

题意

有 \(n\) 个村庄，编号为 \(1, 2, ..., n\) 。有 \(n – 1\) 条道路连接着这些村 庄，从任何一个村庄都可以到达其他任一个村庄。道路长度均为 1。 巡警车每天要到所有的道路上巡逻。警察局设在编号为 \(1\) 的村庄里，每天巡警车总是从警察局出发又回到警察局。

在这些村庄之间建 \(K\) 条新的道路， 可以连接任意两个村庄。每天巡警车必须 经过新建的道路正好一次. 求最小的巡逻距离。

思路

考虑逐条加边。

如果不加边，那么答案显然是 \(2(n-1)\).

如果加一条边，由于必须经过恰好一次，所以在沿着新的道路 \((u,v)\) 走了一次之后，要返回 \(u\) ，必须沿着树上的环的另一半再走一遍，那么这时候 \(u\to v\) 的路径只需要走一次，所以 \(ans=2(n-1)-L-+1.\)

再加一条边，如果环没有重叠，那么按照一条的情况处理即可。否则，重叠部分不会被走过，所以还要走一次，又变成了需要走两次的边。

总结两种情况，得到算法：

1. 找一遍直径，边权取反，长度为 \(L_1\)
2. 再求直径，得到 \(L_2\)
3. \(ans=2(n-1)-(L_1-1)-(L_2-1)\)

代码

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
struct edge
{
        int to,nxt,val;
}e[N<<1];
int n,k,tot=0,mx,head[N],dis[N],pre[N],f[N];
bool vis[N];
queue<int> q;

void add( int u,int v,int w )
{
        e[++tot].to=v; e[tot].val=w; e[tot].nxt=head[u]; head[u]=tot;
}

int bfs( int s )
{
	memset( dis,0x3f,sizeof(dis) );
	q.push( s ); dis[s]=pre[s]=0;
	while ( q.size() )
	{
		int t=q.front(); q.pop();
		for ( int i=head[t]; i; i=e[i].nxt )
			if ( dis[e[i].to]==0x3f3f3f3f )
				dis[e[i].to]=dis[t]+e[i].val,pre[e[i].to]=i,q.push( e[i].to );
	}
	int res=1;
	for ( int x=1; x<=n; x++ )
		if ( dis[x]>dis[res] ) res=x;
	return res;
}

void dp( int x )
{
	vis[x]=1;
	for ( int i=head[x]; i; i=e[i].nxt )
		if ( !vis[e[i].to] )
		{
                        dp( e[i].to );
                        mx=max( mx,f[e[i].to]+f[x]+e[i].val );
                        f[x]=max( f[x],f[e[i].to]+e[i].val );
		}
}

int main()
{
	memset( head,0,sizeof(head) ); tot=1;

	scanf( "%d%d",&n,&k );
	for ( int i=1,u,v; i<n; i++ )
		scanf( "%d%d",&u,&v ),add( u,v,1 ),add( v,u,1 );

        int l=bfs( 1 ); l=bfs(l);
        int L1=dis[l],fl=1; mx=0;
        if ( k==2 )
        {
                for ( ; pre[l]; l=e[pre[l]^1].to )
                        e[pre[l]].val=e[pre[l]^1].val=-1;
                dp( 1 ); fl=2;
        }
        printf( "%d",2*(n-1)-L1-mx+fl );

        return 0;
}

4——P4381 [IOI2008]Island

link

题意

\(N\) 个岛屿组成，从每个岛屿 \(i\) 出发向另外一个岛屿建了一座长度为 \(L_i\) 的桥，可以双向行走。同时，每对岛屿之间都有一艘专用的往来两岛之间的渡船。你希望经过的桥的总长度尽可能长，但受到以下的限制：

• 可以自行挑选一个岛开始游览。
• 任何一个岛都不能游览一次以上。
• 任何时间都可以由当前所在的岛 \(S\) 去另一个从未到过的岛 \(D\)。从 \(S\) 到 \(D\) 有如下方法：
  • 步行：仅当两个岛之间有一座桥，桥长会累加到步行总距离中。
  • 渡船：仅当没有任何桥和以前使用过的渡船的组合可以由 \(S\) 走到 \(D\) (检查是否可到达时应该考虑所有路径，包括经过曾游览过的岛)。

注意，你不必游览所有的岛，也可能无法走完所有的桥。

给定 \(N\) 座桥以及它们的长度，按照上述的规则，计算你可以走过的桥的长度之和的最大值。

思路

每个岛屿一座桥，\(n\) 个岛屿 \(n\) 座桥……诶，不是树？出大问题

于是你不幸地发现，这是基环树，而且还是基环树森林！不过没有关系。由题意可知，如果乘船离开一棵基环树就不能再回来了。（因为回来要坐船，然而你坐过了，所以可达性成立，你就不能坐船了）

于是题目就变成了，求所有基环树的直径之和。

首先，找出基环树的环。然后，对于直径，显然分成两部分，要么在去掉环的某棵子树内，要么是环上一段距离加上两棵不同子树内的距离。

于是可以先预处理出环上每个点在去掉环的前提下，子树内的直径。然后把环展开，分顺时针和逆时针两种情况讨论，每次的 \(res=dis(i,j)+d[i]+d[j]\) ，取max 即可。

代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e6+10;
int n,m,cnt=0,dfn[N],fa[N],pre[N],a[N<<1];
int head[N],tot=1,q[N<<1];
ll ans=0,d[N<<1],f[N],b[N<<1],res;
bool vis[N];

struct edge
{
	int nxt,to,val;
}e[N<<1];

void add( int u,int v,int w )
{
	e[++tot]=(edge){head[u],v,w}; head[u]=tot;
}

void bfs1( int u )		//找环
{
	int tail=0; q[++tail]=u;
	while ( tail )
	{
		int he=q[tail--]; dfn[he]=++cnt;
		for ( int i=head[he]; i; i=e[i].nxt )
		{
			int v=e[i].to;
			if ( i==(pre[he]^1) ) continue;
			if ( !dfn[v] ) { fa[v]=he,pre[v]=i,q[++tail]=v; }
			else if ( !m )
			{
				int p=he;
				for ( ; p!=v; p=fa[p] )
					a[++m]=p,d[m]=e[pre[p]].val,vis[p]=1;
				a[++m]=v; d[m]=e[i].val; vis[v]=1;
			}
		}
	}
}

ll bfs( int x )
{
	int h=1,t=0; q[++t]=x;
	while ( h<=t )
	{
		int u=q[h++];
		for ( int i=head[u]; i; i=e[i].nxt )
		{
			int v=e[i].to;
			if ( vis[v] ) continue;
			fa[v]=u; vis[v]=1; q[++t]=v; pre[v]=e[i].val;
		}
	}
	for ( int i=t; i>1; i-- )
	{
		int v=q[i],u=fa[v],w=pre[v];
		res=max( res,f[u]+f[v]+w );
		f[u]=max( f[u],f[v]+w );
	}
	return f[x];
}

void solve( int x )
{
	m=res=0; bfs1( x );
	if ( !m )  { bfs( x ); ans+=res; return; }
	reverse( a+1,a+1+m ); reverse( d+1,d+1+m );		//反转
	for ( int i=1; i<=m; i++ )
		b[i]=bfs( a[i] );
	for ( int i=m+1; i<=m*2; i++ )		//复制，展环成链
		a[i]=a[i-m],b[i]=b[i-m],d[i]=d[i-m];
	for ( int i=1; i<=m*2; i++ )
		d[i]+=d[i-1];
	int h=0,t=0; q[0]=0;
	for ( int i=1; i<=m*2; i++ )
	{
		while ( h<=t && i-q[h]+1>m ) h++;
		if ( h<=t ) res=max( res,b[i]+b[q[h]]+d[i]-d[q[h]] );
		while ( h<=t && b[q[t]]-d[q[t]]<=b[i]-d[i] ) t--;
		q[++t]=i;
	}
	ans+=res;
}

int main()
{
	scanf( "%d",&n );
	for ( int i=1,v,w; i<=n; i++ )
		scanf( "%d%d",&v,&w ),add( v,i,w ),add( i,v,w );

	for ( int i=1; i<=n; i++ )
		if ( !dfn[i] ) solve( i );

	printf( "%lld\n",ans );
}

---

以上是树的直径部分。

5——P5021 赛道修建

link

题意

有一棵带边权的树，在树上选出 \(m\) 条互不相交的链（点可以重合，但是边不能重合），使得 \(m\) 条链中最短的链最长。

思路

看到这个很容易想到总体思路是二分。

考虑如何判定。然后发现这道题其实藏了一个贪心：对于一棵子树内的所有链，在有最多的儿子对答案做出贡献的前提下，最大化 \(f_i\) 的值。由于 一个点的 \(f\) 最多对答案产生 \(1\) 的贡献，所以让儿子更少贡献，转移更大的 \(f_i\) 不会变优。

那么正解就来了。首先二分出一个 \(mid\) 。然后对于一棵子树，令 \(f_i\) 为以 \(i\) 为根的子树中，最优的不完整的链长（完整的根据上面的贪心分析，已经 \(\ge mid\) ，贡献到答案里去了；不完整就是还要和别的链拼接的）。

暂时不考虑根节点 \(i\) ，对于 \(i\) 所有的儿子，如果能单独贡献则直接计入答案。否则，尝试两两合并这些子链（见题意，点是可以重合的，在根节点合并多少都没有关系），如果长度 \(\ge mid\) 就计入答案。如果都不行，那就在这些剩余的链中选取最长的一条，计入 \(f_i\) ，尝试往上走。于是就可以把所有子节点的 \(f_j\) 排序，贪心找最大的匹配数（能匹配的几条中最小的一个），然后把剩下的转移给 \(f_i\) 即可。

代码

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=5e4+10;
struct edge
{
	int to,nxt; ll val;
}e[N<<1];
int head[N],tot=0,n,m;
ll f[N],subans[N];
vector<int> son[N];

void add( int u,int v,ll w )
{
	e[++tot].to=v; e[tot].nxt=head[u]; e[tot].val=w; head[u]=tot;
}

int get_ans( int u,int pos,int cnt,ll x )
{
	int res=0,l=0;
	for ( int r=cnt-1; r; r-- )
	{
		r-=(r==pos);
		while ( l<r && son[u][l]+son[u][r]<x ) ++l;
		l+=(l==pos);
		if ( l>=r ) break;
		res++; l++;
	}
	return res;
}

void dfs( int u,int fa,ll x )
{
	f[u]=subans[u]=0; son[u].clear();
	for ( int i=head[u]; i; i=e[i].nxt )
	{
		int v=e[i].to;
		if ( v==fa ) continue;
		dfs( v,u,x ); f[v]+=e[i].val;
		if ( f[v]>=x ) subans[u]++;
		else son[u].push_back( f[v] );
	}
	int cnt=son[u].size(); sort( son[u].begin(),son[u].end() );
	int l=0,r=cnt,sub=0,res;
	for ( int r=cnt-1; r; r-- )		//配对
	{
		while ( l<r && son[u][l]+son[u][r]<x ) l++;
		if ( l>=r ) break;
		sub++; l++;
	}
	subans[u]+=sub;
	if ( sub*2==cnt ) return;
	l=0; r=cnt-1;
	while ( l<=r )		//二分找最大的一个mid，使得首先满足子树要求
	{
		int mid=(l+r)>>1;
		int tmp=get_ans( u,mid,cnt,x );
		if ( tmp==sub ) res=mid,l=mid+1;
		else r=mid-1;
	}
	f[u]=son[u][res];	//记入f[i]
}

bool check( ll x )
{
	int res=0; dfs( 1,0,x );
	for ( int i=1; i<=n; i++ )		//每个点的贡献
		res+=subans[i];
	return res>=m;
}

int main()
{
	ll l=0,r=0;
	scanf( "%d%d",&n,&m );
	for ( int i=1; i<n; i++ )
	{
		int u,v; ll w; scanf( "%d%d%lld",&u,&v,&w );
		add( u,v,w ); add( v,u,w ); r+=w;
	}

	r/=(ll)m; ll ans=0;
	while ( l<=r )
	{
		ll mid=(l+r)>>1;
		if ( check(mid) ) ans=mid,l=mid+1;
		else r=mid-1;
	}

	printf( "%lld",ans );

	return 0;
}

6——P1852 跳跳棋

link

题意

跳跳棋是在一条数轴上进行的。棋子只能摆在整点上。每个点不能摆超过一个棋子。棋盘上有3颗棋子，分别在 \(a，b，c\) 这三个位置。我们要通过最少的跳动把他们的位置移动成 \(x，y，z\) 。（棋子是没有区别的）

跳动的规则很简单，任意选一颗棋子，对一颗中轴棋子跳动。跳动后两颗棋子距离不变。一次只允许跳过1颗棋子。

判断是否可以完成任务。如果可以，输出最少需要的跳动次数。

思路

神仙题……非常巧妙地建模。只能说：女少口阿

首先，对于中轴棋子为 \(b\) （中间那个）的情况，显然一直往中间跳可以一直减小范围，直到不能跳为止。这时候就得到了一个非常有用的“Basic” 状态，也就是“根状态”（这怎么跟某道字符串手玩题这么像啊）

然后把 \(b\) 往左右跳的情况看成左右节点状态，那么所有状态构成了一棵二叉树。对于棋盘上所有的 \(a,b,c\) ，状态构成了一个森林。

那么，如果 \((a,b,c)\to (x,y,z)\) ，首要条件是在同一棵树上。这样第一问就解决了。

考虑状态怎么去树根。利用 LCA 的思想，把两个状态到根的距离调整到一样，然后二分向上的步数，最后找到一个 \(L\) 使得两个状态向上 \(L\) 步相遇，那么总答案就是 高度差加上二分答案的两倍。

代码

#include <bits/stdc++.h>
using namespace std;
const int inf=1e9+7;
int sx,sy,sz,dep,mx;

void init( int &x,int &y,int &z )
{
	x+=inf; y+=inf; z+=inf;
	if ( y>z ) swap( y,z );
	if ( x>y ) swap( x,y );
	if ( y>z ) swap( y,z );
}

void dfs( int x,int y,int z,int step )
{
	int del1=y-x,del2=z-y;
	if ( step==mx || del1==del2 ) { sx=x,sy=y,sz=z; dep=step; return; }
	if ( del1>del2 )
	{
		swap( del1,del2 ); int del=del2/del1;
		if ( del2%del1==0 ) del--;
		if ( step+del<=mx ) dfs( x,y-del*del1,z-del*del1,step+del );
		else dfs( x,y-(mx-step)*del1,z-(mx-step)*del1,mx );
	}
	else
	{
		int del=del2/del1;  del-=(del2%del1==0);
		if ( step+del<=mx ) dfs( x+del*del1,y+del*del1,z,step+del );
		else dfs( x+(mx-step)*del1,y+(mx-step)*del1,z,mx );
	}
}

int main()
{
	int x,y,z,a,b,c;
	scanf( "%d%d%d",&a,&b,&c ); init( a,b,c );
	scanf( "%d%d%d",&x,&y,&z ); init( x,y,z );

	mx=inf;
	dfs( a,b,c,0 ); int sa=sx,sb=sy,sc=sz,sd=dep;
	dfs( x,y,z,0 );
	if ( sx!=sa || sy!=sb || sz!=sc ) { printf( "NO" ); return 0; }
	printf( "YES\n" );
//------------query1-------------------
	int ans=0;
	if ( sd>dep )
	{
		ans=sd-dep; mx=sd-dep;
		dfs( a,b,c,0 ); a=sx; b=sy; c=sz;
	}
	if ( sd<dep )
	{
		ans=dep-sd; mx=dep-sd;
		dfs( x,y,z,0 ); x=sx,y=sy,z=sz;
	}

	int l=0,r=inf;
	while ( l<=r )
	{
		mx=(l+r)>>1;
		dfs( a,b,c,0 ); sa=sx,sb=sy,sc=sz;
		dfs( x,y,z,0 );
		if ( sa!=sx || sb!=sy || sc!=sz ) l=mx+1;
		else r=mx-1;
	}

	printf( "%d",(l<<1)+ans );
}

Last

To be continue...