2021牛客暑期多校训练营8 - J - Tree ( ST表 + 模拟 )

题目链接：点击进入

题目

题意

一棵树， A 在 s 点，B 在 t 点，A 先手，两个人移动后，移动之前的点与点周围相连的边都会消失，每个人移动的步数，就是自己的分数，每个人都想 自己的分数 - 对方的分数 差值 最大，问最后 A的得分 - B的得分 差值是多少。

思路

我们大概可以想到，如果有人没有走在两人之间的那条路上，那么就是互不影响的，也就是说，如果其中一个人离开了两人之间的那条路，那么另一个人就一定走可以走的路中最长的那条路。
我们将 s 、t 之间的路径看作一段区间，以 s 为起点，将路上的点标号 ( 1 ~ cnt , cnt 为路径经过的点数 ) ，那么我们大概可以模拟一下两者的过程：
( d [ i ] 表示点 i 的最长的子树的长度，A 从 $l$ = 1 点向右行进，B 从 $r$ = cnt 点向左行进，A先走 ( $l$ 为 A 当前位置，$r$ 为 B 当前位置 )

1、A不走这条路，选择走 $l$ 点的子树，那么肯定走 $l$ 点的子树中最长的那条，A 的分数也就是 $d_l+l-1$ ，而这时候，B 肯定走自己目前能走的最长的路，也就是从 $[l+1,r]$ 的所有子树中找一个目前离 $r$ 点最远的点，转换一下，B 的得分就是 $ma{x}_{i=l+1}^r(d_i+cnt-i)$ ，然后游戏结束，答案就是：$(d_l+l-1)-ma{x}_{i=l+1}^r(d_i+cnt-i)$；

2、A走这条路，从当前的点 $l$ 向右行进一个单位，到达 $l=l+1$ ，

然后轮到 B ( 注意，每一轮的 $l、r$ 都是由上一轮递归而来，值不一定相同 ) ：

1、B 不走这条路，选择走 $r$ 点的子树，那么也肯定走这个点的子树中最长的那条，B 得分 $d_r+cnt-r$ ，那这时候，A 肯定走剩下能走的最长的，也就是从 $[l,r-1]$ 的所有子树中找一个目前离 $l$ 点最远的点，得分就是 $ma{x}_{i=l}^{r-1}(d_i+i-1)$ ，然后游戏结束，答案就是 $ma{x}_{i=l}^{r-1}(d_i+i-1)-(d_r+cnt-r)$ ；

2、B 走这条路，从当前的点 $r$ 向左行进一个单位，到达 $r=r-1$ ,

然后轮到 A …

一直递归下去，一直到 $l==r$ 即可停止，因为要求的这个差值是 A 的得分 - B 的得分，所以 A 肯定想这个差值越大越好，而 B 肯定是想这个差值越小越好，因此中间要是 A 操作，对 A 的两种情况的结果取最大值，要是 B 操作，对 B 的两种情况取最小值。最终得到的就是答案。
（ 中间用到的区间最值可以用 ST表 解决，求$s、t$ 路径以及点的子树中最长的长度可以用 dfs 解决，后面的模拟可以用递归解决 ）

代码

// Problem: Tree
// Contest: NowCoder
// URL: https://ac.nowcoder.com/acm/contest/11259/J
// Memory Limit: 524288 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//#pragma GCC optimize(3)//O3
//#pragma GCC optimize(2)//O2
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define best 131 
#define INF 0x3f3f3f3f3f3f3f3f
#define pii pair<int,int>
#define lowbit(x) x & -x
#define inf 0x3f3f3f3f
//#define int long long
//#define double long double
//#define rep(i,x,y) for(register int i = x; i <= y;++i)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const int maxn=1e6+10;
const int mod=1e9+7;
const double eps=1e-9;
const int N=5e3+10;
/*--------------------------------------------*/
inline int read()
{
    int k = 0, f = 1 ;
    char c = getchar() ;
    while(!isdigit(c)){if(c == '-') f = -1 ;c = getchar() ;}
    while(isdigit(c)) k = (k << 1) + (k << 3) + c - 48 ,c = getchar() ;
    return k * f ;
}
/*--------------------------------------------*/

bool vis[maxn];
int n,s,t,d[maxn];
int path[maxn],cnt;
int lmx[maxn][21];
int rmx[maxn][21];
vector<int>v[maxn];

bool dfs1(int pos,int fa)//找s、t之间路径，并将其转换为序列
{
	if(pos==s)
	{
		path[++cnt]=pos;
		return 1;
	}
	for(int i=0;i<v[pos].size();i++)
	{
		int to=v[pos][i];
		if(to==fa) continue;
		int flag=dfs1(to,pos);
		if(flag) 
		{
			path[++cnt]=pos;
			return 1;
		} 
	}
	return 0;
}

int dfs2(int pos,int fa)//查找最长子树的长度
{
	int maxx=0;
	for(int i=0;i<v[pos].size();i++)
	{
		int to=v[pos][i];
		if(to==fa||vis[to]) continue;
		maxx=max(maxx,dfs2(to,pos));
	}
	return maxx+1;
}

int query(int l,int r,int flag)//查找区间最大值，flag = 0 是对 A ，1 是对 B 
{
	int k=log2(r-l+1);
	if(!flag) return max(lmx[l][k],lmx[r-(1<<k)+1][k]);
	return max(rmx[l][k],rmx[r-(1<<k)+1][k]);
}

int dfs3(int l,int r,int flag)//模拟操作，flag = 0 是 A 操作，1 是 B 操作
{
	if(l==r)
	{
		if(flag==0) return inf;
		else return -inf;
	}
	if(!flag) return max((d[l]+l-1)-(query(l+1,r,1)),dfs3(l+1,r,1));
	else return min((query(l,r-1,0))-(d[r]+cnt-r),dfs3(l,r-1,0));
}

int main() 
{
//	ios::sync_with_stdio(false);
//	cin.tie(0);cout.tie(0);
	cin>>n>>s>>t;
	for(int i=1;i<n;i++)
	{
		int x,y;
		cin>>x>>y;
		v[x].push_back(y);
		v[y].push_back(x);
	}
	dfs1(t,0);
	for(int i=1;i<=cnt;i++) vis[path[i]]=1;
	for(int i=1;i<=cnt;i++)
		d[i]=dfs2(path[i],0)-1;
	for(int i=1;i<=cnt;i++)
	{
		lmx[i][0]=d[i]+i-1;
		rmx[i][0]=d[i]+cnt-i;
	}
	for(int j=1;(1<<j)<=cnt;j++)
	{
		for(int i=1;i+(1<<j)-1<=cnt;i++)
		{
			lmx[i][j]=max(lmx[i][j-1],lmx[i+(1<<(j-1))][j-1]);
			rmx[i][j]=max(rmx[i][j-1],rmx[i+(1<<(j-1))][j-1]);
		}
	}
	int ans=dfs3(1,cnt,0);
	cout<<ans<<endl;
    return 0;
}