[AGC027F]Grafting

题意：给定两棵树，一次操作形如：选一个未被选过的叶子，改变它的一条出边，问能否在第一棵树上做一些操作使得它变成第二棵树，如果能则询问最小操作次数

如果答案不是$n$，那么存在一个点$r$没有被选中过

如果$r$和$v$在两棵树上都相邻，那么我们不会改变$(v,r)$，因为如果改变了那么一定是选中$v$，以后没有办法再把这条边变回来

如果$u$和$v$在两棵树上都相邻，那么我们不会改变$(u,v)$，因为只能选叶子，所以改变这条边一定选$u$，以后要把这条边变回来只能选$v$，而$v$作为叶子的唯一出边是$(v,r)$，所以这条边也不能动

以此类推，我们从$r$开始搜索，只走那些两棵树的公共边，得到的连通块中的边是不会被改变的，连通块中的点同样不会被选中，因为它们作为叶子时唯一的出边已经被硬点为不可改变

剩下的边是一定要改变的，并且改变它只能由选定端点中更深的那个来实现，我们想知道是否存在一个合法的顺序使得按这个顺序选择点能满足每次选到的都是叶子

在第一棵树中，设$fa_x=y$，如果$x,y$都能被选，那么选$y$之前一定要先选$x$，在第二棵树中，如果$fa_x=y$且$x,y$都能被选，那么选$x$之前要先选$y$，把限制关系建成一个有向图，如果没有环就有解了

总时间复杂度$O(n)$，但这样并不能统计到答案为$n$的情况，于是我们再$O(n^2)$枚举第一次操作，被选中的那个点之后就不能选了，于是套用上面的算法即可，总时间复杂度$O(n^3)$

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
const int inf=2147483646;
int fb;
struct tree{
	int h[60],nex[110],to[110],M;
	void reset(){
		M=0;
		memset(h,0,sizeof(h));
	}
	void add(int a,int b){
		M++;
		to[M]=b;
		nex[M]=h[a];
		h[a]=M;
	}
	int fa[60];
	void dfs(int x){
		for(int i=h[x];i;i=nex[i]){
			if(to[i]!=fa[x]&&to[i]!=fb){
				fa[to[i]]=x;
				dfs(to[i]);
			}
		}
	}
}a,b;
int d[60],v[60],n,M;
bool f[60];
void dfs(int fa,int x){
	int i,tm;
	tm=++M;
	f[x]=1;
	for(i=a.h[x];i;i=a.nex[i])v[a.to[i]]=tm;
	for(i=b.h[x];i;i=b.nex[i]){
		if(b.to[i]!=fa&&v[b.to[i]]==tm&&b.to[i]!=fb)dfs(x,b.to[i]);
	}
}
struct graph{
	int h[60],nex[110],to[110],M;
	bool v[60],ins[60];
	void reset(){
		M=0;
		memset(h,0,sizeof(h));
		memset(v,0,sizeof(v));
		memset(ins,0,sizeof(ins));
	}
	void add(int a,int b){
		M++;
		to[M]=b;
		nex[M]=h[a];
		h[a]=M;
	}
	bool dfs(int x){
		v[x]=1;
		ins[x]=1;
		for(int i=h[x];i;i=nex[i]){
			if(!v[to[i]]){
				if(!dfs(to[i]))return 0;
			}else if(ins[to[i]])
				return 0;
		}
		ins[x]=0;
		return 1;
	}
}g;
int solve(int r){
	fb=r;
	int i,cnt;
	memset(a.fa,0,sizeof(a.fa));
	a.dfs(r);
	memset(b.fa,0,sizeof(b.fa));
	b.dfs(r);
	memset(f,0,sizeof(f));
	dfs(0,r);
	g.reset();
	cnt=0;
	for(i=1;i<=n;i++){
		if(!f[i]){
			if(!f[a.fa[i]])g.add(i,a.fa[i]);
			if(!f[b.fa[i]])g.add(b.fa[i],i);
			cnt++;
		}
	}
	for(i=1;i<=n;i++){
		if(!g.dfs(i))return inf;
	}
	return cnt;
}
void work(){
	int i,j,x,y,ans;
	scanf("%d",&n);
	a.reset();
	b.reset();
	memset(d,0,sizeof(d));
	for(i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		a.add(x,y);
		a.add(y,x);
		d[x]++;
		d[y]++;
	}
	for(i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		b.add(x,y);
		b.add(y,x);
	}
	ans=inf;
	for(i=1;i<=n;i++)ans=min(ans,solve(i));
	for(i=1;i<=n;i++){
		if(d[i]==1){
			for(j=1;j<=n;j++){
				if(j!=i){
					x=a.to[a.h[i]];
					a.to[a.h[i]]=j;
					ans=min(ans,solve(i)+1);
					a.to[a.h[i]]=x;
				}
			}
		}
	}
	if(ans==inf)ans=-1;
	printf("%d\n",ans);
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--)work();
}

转载于:https://www.cnblogs.com/jefflyy/p/9714948.html