CodeForces - 1328E Tree Queries(dfs序/LCA)

题目链接：点击查看

题目大意：给出一棵以点 1 为根节点的树，接下来有 m 次询问，每次询问给出 k 个点，题目问我们能否找到一个点 u ，使得从根节点到点 u 的简单路径，到 k 个点的每个点的距离都小于等于 1 

题目分析：我的第一反应是用lca，仿照bfs那样，逐层询问每两个点之间的lca，但是不太会操作，队友和我说可以随便找一条最长的链然后检查，不过复杂度顶不住，赛后补题的时候，想到了可以用dfs序优化，这样总的时间复杂度就下降到了O( n )了

具体做法就是预处理出树上的dfs序，以及每个节点的深度，对于每次需要询问的 k 个点，我们找到深度最深的那个点作为点 u ，因为dfs序主要是负责检查某个点是否在子树中的，所以只要这个最深的点 u 都位于这 k 个点，或者这些点父节点的子树中，就说明肯定可以找到一条满足条件的树链

2020.3.27更新：

补一下lca的做法，仍然是选择深度最深的结点作为点 u ，对于 k 个点，每个点都与点 u 求一下 lca ，如果想要满足题目中的距离限制，就要使得每个lca不是其本身，就是其父节点，时间复杂度为nlogn

代码：

dfs序：
 

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<unordered_map>
using namespace std;
      
typedef long long LL;

typedef unsigned long long ull;
      
const int inf=0x3f3f3f3f;
 
const int N=2e5+100;

vector<int>node[N];

int fa[N],in[N],out[N],deep[N],cnt;

int k,max_deep,a[N];

void dfs(int u,int f,int dep)
{
	fa[u]=f;
	deep[u]=dep;
	in[u]=++cnt;
	for(auto v:node[u])
	{
		if(v==f)
			continue;
		dfs(v,u,dep+1);
	}
	out[u]=cnt;
}

bool check(int a,int b)
{
	return in[a]<=in[b]&&out[b]<=out[a];
}

bool solve()
{
	for(int i=1;i<=k;i++)
	{
		if(!check(a[i],max_deep)&&!check(fa[a[i]],max_deep))
			return false;
	}
	return true;
}

int main()
{
#ifndef ONLINE_JUDGE
//	freopen("input.txt","r",stdin);
//	freopen("output.txt","w",stdout);
#endif
//	ios::sync_with_stdio(false);
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		node[u].push_back(v);
		node[v].push_back(u);
	}
	dfs(1,-1,0);
	while(m--)
	{
		scanf("%d",&k);
		max_deep=0;
		for(int i=1;i<=k;i++)
		{
			scanf("%d",a+i);
			if(max_deep==0||deep[max_deep]<deep[a[i]])
				max_deep=a[i];
		}
		if(solve())
			puts("YES");
		else
			puts("NO");
	}
	
	
	
	
	
	
	
	
	
	
    return 0;
}

LCA：

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<unordered_map>
using namespace std;
      
typedef long long LL;

typedef unsigned long long ull;
      
const int inf=0x3f3f3f3f;
 
const int N=2e5+100;

vector<int>node[N];

int deep[N],dp[N][20],limit;

int a[N],max_deep,k; 
 
void dfs(int u,int fa,int dep)
{
	deep[u]=dep;
	dp[u][0]=fa;
	for(int i=1;i<=limit;i++)
		dp[u][i]=dp[dp[u][i-1]][i-1];
	for(auto v:node[u])
	{
		if(v!=fa)
			dfs(v,u,dep+1);
	}
}

int LCA(int x,int y)
{
	if(deep[x]<deep[y])
		swap(x,y);
	for(int i=limit;i>=0;i--)
		if(deep[x]-deep[y]>=(1<<i))
			x=dp[x][i];
	if(x==y)
		return x;
	for(int i=limit;i>=0;i--)
		if(dp[x][i]!=dp[y][i])
		{
			x=dp[x][i];
			y=dp[y][i];
		}
	return dp[x][0];
}

bool solve()
{
	for(int i=1;i<=k;i++)
	{
		int lca=LCA(a[i],max_deep);
		if(lca!=a[i]&&lca!=dp[a[i]][0])
			return false;
	}
	return true;
}

int main()
{
#ifndef ONLINE_JUDGE
//	freopen("input.txt","r",stdin);
//	freopen("output.txt","w",stdout);
#endif
//	ios::sync_with_stdio(false);
	int n,m;
	scanf("%d%d",&n,&m);
	limit=log2(n)+1;
	for(int i=1;i<n;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		node[u].push_back(v);
		node[v].push_back(u);
	}
	dfs(1,0,0);
	while(m--)
	{
		scanf("%d",&k);
		max_deep=0;
		for(int i=1;i<=k;i++)
		{
			scanf("%d",a+i);
			if(max_deep==0||deep[max_deep]<deep[a[i]])
				max_deep=a[i];
		}
		if(solve())
			puts("YES");
		else
			puts("NO");
	}
	
	
	
	
	
	
	
	
	
	
    return 0;
}