2021牛客暑期多校训练营8 J题: Tree

J题: Tree

原题链接:https://ac.nowcoder.com/acm/contest/11259/J

题目大意

有两个人在 $n$ 个点的树上玩博弈游戏，节点编号从 $1$ 到 $n$ ，先手初始在 $s$ 节点，后手在 $t$ 节点。
双方轮流操作，每次将移动到当前所在节点的某个邻居上，并删除原先节点和其相邻的所有边。双方尽可能地移动，当两个玩家都不能移动时，游戏结束，每个玩家的分数为各自的移动步数。
双方都试图最大化（自己分数-对手分数），且双方均采取最优策略，求先手得分与后手得分之差。

题解

首先我们考虑两人操作的相互关联性，显然， $s$ 与 $t$ 之间有一条唯一路径，双方只有同时在这一路径上移动时才会互相影响，若一方离开了这一路径，则两人处于两个不同的联通分块中，即不相互影响。
那么当两人同时在该路径上移动时，移动方式必然为互相靠近，直至一方离开路径或两者相邻(此时两人都只能选择离开当前路径)。
我们可以将中间的这一条路径展开成为一条长度为 $m$ 的链(原 $s$ 点与 $t$ 点分别在链上表示为 $1$ 和 $m$ )，并预先算出 $di{s}_i$ 表示从第 $i$ 个点离开路径后可进行的最大操作次数(以每个点为根跑dfs，记录最大深度)，然后考虑博弈。我们设:

1. $f_{l,r}$ 表示先后手位置分别移至链上 $l$ 与 $r$ 处时，轮到先手操作时先手可最大化得到的(先手分数-后手分数)
2. $g_{l,r}$ 表示先后手位置分别移至链上 $l$ 与 $r$ 处时，轮到后手操作时后手可最大化得到的(后手分数-先手分数)

显然，两者此时都有两种策略:直接离开路径，或更进一步然后转换到对方操作。
可得转移式为:
$$\begin{array}{rl}{f}_{l,r}& =\max (1-g_{l+1,r},di{s}_l-\underset{i=l+1}{\overset{r}{\max }}di{s}_i+r-i)\\ g_{l,r}& =\max (1-f_{l,r-1},di{s}_r-\underset{i=l}{\overset{r-1}{\max }}di{s}_i+i-l)\end{array}$$

$\max$ 的前一项表示继续靠近并转入对方操作，取对方操作得到的最大(对方分数-当前操作方分数)即可，注意对当前操作方而言计算应为(当前操作方分数-对方分数)，所以应为减去，而且不要忘记加上当前向前靠近所走的一步。
$\max$ 的第二项表示直接离开路径，此时枚举对方可选的离开位置，取最大的对方操作数(对方总是采取最优策略)减去即可(对于 $di{s}_i\pm i$ 的项，可以通过ST表+RMQ实现 $O(1)$ 查询，其中的常数项 $l/r$ 可以直接提出，简化过程减小复杂度)。
若上式采用递归实现，则终止条件应为 $l+1=r$ (即先后手处于相邻状态)，此时返回 $di{s}_{当前操作方}-di{s}_{对方}$ 即可。

参考代码

#include<bits/stdc++.h>
#define ll long long
#define For(i,n,m) for(int i=n;i<=m;i++)
#define FOR(i,n,m) for(int i=n;i>=m;i--)
using namespace std;

void read(int &x){
	int ret=0;
	char c=getchar(),last=' ';
	while(!isdigit(c))last=c,c=getchar();
	while(isdigit(c))ret=ret*10+c-'0',c=getchar();
	x=last=='-'?-ret:ret;
}

const int MAXN=5e5+5;
int n,m,s,t,maxd,in[MAXN];
int dis[MAXN],_log[MAXN],STs[MAXN][20],STt[MAXN][20];
vector<int>e[MAXN],path;

void dfs(int x,int fa){//dfs跑出s到t之间的路径
	int son;
	For(i,0,e[x].size()-1){
		son=e[x][i];
		if(son==fa)continue;
		dfs(son,x);
		if(in[son])in[x]=1;//若其子节点为路径点,则该点也为路径点
	}
	if(in[x])path.push_back(x);//若在路径上,将点存入path中,注意递归的顺序是反向的,所以搜索若以t为根则可以保证s在路径中为首元素
}

void dfsv(int x,int fa,int d){//跑出路径上每个点离开时的最大操作次数(即其往下的最长链长度/深度)
	maxd=max(maxd,d);//取最大深度
	int son;
	For(i,0,e[x].size()-1){
		son=e[x][i];
		if(son==fa||in[son])continue;//注意,若子节点为路径上点则跳过,因为此时的策略是离开路径
		dfsv(son,x,d+1);
	}
}

void init(){//读入
	read(n),read(s),read(t);
	int u,v;
	For(i,2,n){
		read(u),read(v);
		e[u].push_back(v);
		e[v].push_back(u);
	}
}

void dfsinit(){//预处理出链(路径)与dis数组
	in[s]=in[t]=1;//标记s和t
	dfs(t,-1);//以t为根则保证s在路径中为首元素
	m=path.size();//记录路径总长 
	For(i,0,m-1){
		maxd=0;
		dfsv(path[i],-1,0);//跑出最长链长度/深度
		dis[i+1]=maxd;//更新dis,注意下标
	}
}

void STinit(){//初始化ST表,注意要分为两块(+i与-i)
	For(i,2,m)_log[i]=_log[i>>1]+1;//预处理log数组,方便以后RMQ
	For(i,1,m){
		STs[i][0]=dis[i]+i;//+i项初始化
		STt[i][0]=dis[i]-i;//-i项初始化
	}
	int k=_log[m],limit,a,b;
	For(j,1,k){
		limit=m-(1<<j)+1;
		For(i,1,limit){
			a=STs[i][j-1],b=STs[i+(1<<j-1)][j-1];
			STs[i][j]=max(a,b);//+i项更新
			a=STt[i][j-1],b=STt[i+(1<<j-1)][j-1];
			STt[i][j]=max(a,b);//-i项更新
		}
	}
}

int RMQs(int l,int r){//+i表查询
	int k=_log[r-l+1];
	int a=STs[l][k],b=STs[r-(1<<k)+1][k];
	return max(a,b);
}

int RMQt(int l,int r){//-i表查询
	int k=_log[r-l+1];
	int a=STt[l][k],b=STt[r-(1<<k)+1][k];
	return max(a,b);
}

int G(int l,int r);//函数声明,因为F中需要调用G
int F(int l,int r){//此时先手操作
	if(l+1==r)return dis[l]-dis[r];//边界,返回(先手操作数-后手操作数)
	return max(1-G(l+1,r),dis[l]-(r+RMQt(l+1,r)));//转移
}

int G(int l,int r){//此时后手操作
	if(l+1==r)return dis[r]-dis[l];//边界,返回(后手操作数-先手操作数)
	return max(1-F(l,r-1),dis[r]-(RMQs(l,r-1)-l));//转移
}

void get(){
	printf("%d\n",F(1,m));//答案为F(1,m),即初始状态先手操作
}

int main()
{//典中典模块化
	init();
	dfsinit();
	STinit();
	get();
	return 0;
}