Kingdom and its Cities

一、题目

点此看题

二、解法

设$dp[u]$为解决以$u$为根子树中的关键点不能两两联通的最小花费，由于更新的需要，我们要打上一个标记表示该子树中的关键点还能不能通向外面，我们不需要将它放进$dp$中，因为把问题留给父亲解决一定是最优的，这种延迟的思想在很多题目中均有体现，我们尝试分类讨论转移：

• $u$是关键点，我们先对$dp[v]$求和，这时候判断一下$(u,v)$是不是挨在一起且$v$是关键点，如果存在那么不能够使得两两不联通，我们还有处理标记，如果$v$有标记，那么要多炸毁一个点。
• $u$不是关键点，还是先求和，我们找出有多少个$v$被打上了标记，如果个数是$1$，那么把当前点打上标记，否则我们必须炸毁当前节点。

然后这个过程可以用虚树优化，时间复杂度$O(n\log n)$。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;
#define inf 0x3f3f3f3f
const int MAXN = 100005;
int read()
{
	int x=0,flag=1;char c;
	while((c=getchar())<'0' || c>'9') if(c=='-') flag=-1;
	while(c>='0' && c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return x*flag;
}
int n,m,k,k1,cnt,tot,f[MAXN],dfin[MAXN],dfou[MAXN],vis[MAXN],fa[MAXN][20];
int fuck,dep[MAXN],pd[MAXN],a[MAXN*2],dp[MAXN],flag[MAXN];
stack<int> s;
vector<int> G[MAXN];
struct edge
{
	int v,next;
}e[MAXN*2];
bool cmp(int a,int b)
{
	int t1=a>0?dfin[a]:dfou[-a];
	int t2=b>0?dfin[b]:dfou[-b];
	return t1<t2;
}
void dfs1(int u,int p)
{
	dfin[u]=++cnt;
	dep[u]=dep[p]+1;
	fa[u][0]=p;
	for(int i=1;i<=19;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1];
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(v==p) continue;
		dfs1(v,u);
	}
	dfou[u]=++cnt;
}
int get(int u,int v)
{
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=19;i>=0;i--)
		if(dep[fa[u][i]]>=dep[v])
			u=fa[u][i];
	if(u==v) return u;
	for(int i=19;i>=0;i--)
		if(fa[u][i]^fa[v][i])
			u=fa[u][i],v=fa[v][i];
	return fa[u][0];
}
void dfs(int u,int p)
{
	if(pd[u])
	{
		for(int i=0;i<G[u].size();i++)
		{
			int v=G[u][i];
			if(v==p) continue;
			dfs(v,u);
			dp[u]+=dp[v];
			if(pd[v] && dep[v]-dep[u]==1) fuck=1;
			if(flag[v]) dp[u]++;
			dp[v]=flag[v]=pd[v]=vis[v]=0;
		}
		flag[u]=1;
	}
	else
	{
		int cot=0;
		for(int i=0;i<G[u].size();i++)
		{
			int v=G[u][i];
			if(v==p) continue;
			dfs(v,u);
			dp[u]+=dp[v];
			if(flag[v]) cot++;
			dp[v]=flag[v]=pd[v]=vis[v]=0;
		}
		if(cot==1) flag[u]=1;
		if(cot>1) dp[u]++;
	}
	G[u].clear();
}
int main()
{
	n=read();
	for(int i=1;i<n;i++)
	{
		int u=read(),v=read();
		e[++tot]=edge{v,f[u]},f[u]=tot;
		e[++tot]=edge{u,f[v]},f[v]=tot;
	}
	dfs1(1,0);
	m=read();
	while(m--)
	{
		k=k1=read();
		for(int i=1;i<=k;i++)
		{
			a[i]=read();
			vis[a[i]]=pd[a[i]]=1;
		}
		sort(a+1,a+1+k,cmp);
		for(int i=1;i<k1;i++)
		{
			int t=get(a[i],a[i+1]);
			if(!vis[t]) a[++k]=t,vis[t]=1;
		}
		if(!vis[1]) a[++k]=1,vis[1]=1;
		k1=k;
		for(int i=1;i<=k1;i++)
			a[++k]=-a[i];
		sort(a+1,a+1+k,cmp);
		for(int i=1;i<=k;i++)
		{
			if(a[i]>0)
				s.push(a[i]);
			else
			{
				int t=s.top();s.pop();
				if(t==1) break;
				G[t].push_back(s.top());
				G[s.top()].push_back(t);
			}
		}
		dfs(1,0);
		if(fuck) puts("-1");
		else printf("%d\n",dp[1]);
		fuck=flag[1]=dp[1]=pd[1]=vis[1]=0;
	}
}