1、无脑暴力dfs: O(n*m)
2、LCA/tarjan+离线处理: O(n+m)
3、LCA/树链剖分: O(nlogn+m)~O(nlogn+mlogn)
4、LCA/倍增思想(有空再补):
tarjan:
实验内容:
题目要求:某个太空神秘国度中有很多美丽的小村,从太空中可以想见,小村间有路相连,更精确一点说,任意两村之间有且仅有一条路径。小村 A 中有位年轻人爱上了自己村里的美丽姑娘。每天早晨,姑娘都会去小村 B 里的面包房工作,傍晚 6 点回到家。年轻人终于决定要向姑娘表白,他打算在小村 C 等着姑娘路过的时候把爱慕说出来。问题是,他不能确定小村 C 是否在小村 B 到小村 A 之间的路径上。你可以帮他解决这个问题吗?
输入要求:输入由若干组测试数据组成。每组数据的第 1 行包含一正整数 N ( l < N < 50000 ) , 代表神秘国度中小村的个数,每个小村即从0到 N - l 编号。接下来有 N -1 行输入,每行包含一条双向道路的两个端点小村的编号,中间用空格分开。之后一行包含一正整数 M ( l < M < 500000 ) ,代表着该组测试问题的个数。接下来 M 行,每行给出 A 、 B 、 C 三个小村的编号,中间用空格分开。当 N 为 O 时,表示全部测试结束,不要对该数据做任何处理。
输出要求:对每一组测试给定的 A 、 B 、C,在一行里输出答案,即:如果 C 在 A 和 B 之间的路径上,输出 Yes ,否则输出 No.
实验原理:
把村子当作节点,村子间的路当作边就能将问题转化成图的问题。又因为任意两村之间有且仅有一条路径,而输入的村子数为n且村之间的边数也只有n-1,所以可以判断出该图是一颗树,问题也就简化为树的问题。
- 数据结构及算法设计思想
数据结构:
经过实验原理的分析,树上的问题可以采用树形结构来存储数据进行处理。
算法设计思想:
整体思路是采用Tarjan算法的离线处理。离线处理就是先把询问存起来,在一次遍历中进行缩点同时把所以询问一次性解决,所以时间复杂度是O(n+m)。
图的连边采用邻接表形式,边是双向边。
整理询问的基本思路是用结构体存储询问的A,B,C村的编号a,b,c,A,B村的最近公共祖先lca以及询问的编号id。用vector容器head_q[i]表示村子编号为i的存储的有关的询问的下标。
遍历的基本思路是Tarjan算法:
- 任取一点为根节点(本实验我采用的根是编号1),从根开始。
- 遍历该节点u所以子节点v,并标注这些子节点v已被访问过。
- 若v还有子节点,返回第二步,否则下一步。
- 合并v到u上。
- 寻找于当前点u有关的询问。
- 处理询问。
询问处理:重点在于处理出Yes的询问。分情况讨论:
- 当前搜索到的节点为c,那么如果a,b都搜索过了,也就是说a,b以下的节点已经合并到c了,如图6-1,这时无法之间断定c是a,b路径上的点,因为可能是a,b最近公共祖先以上的父节点。那么就判断:如果a,b的最近公共祖先不是c的话该询问就是No,如果是就是Yes。
图6-1
- 当前搜索到c,如果a被搜索过,且a的当前祖先是c那么a就是c的子树下的节点,那么肯定存在一条路径能到达b,如同6-2,同理如果b搜过也一样处理。
图6-2
- A,B的最近公共祖先的处理是在处理询问的同时更新的。如果a搜索过,而b还没搜索过,那么它们的lca就是a已经合并到的节点,如图6-3,a,b的最近公共祖先就是9。同理b搜过,a没搜过也可以处理出lca。
图6-3
合并处理:采用并查集的方式,每次搜索完一个节点就向它的的父亲节点合并。因为处理询问时要查询节点所在点集的根来判断lca,所以并查集需要压缩路径来优化。如图6-4。
father数组初始时指向自己本身father[i] = i
int Find(int x)
{
return x == father[x] ? x : father[x] = Find(father[x]);
}
图6-4
#include<cstring>
#include<iostream>
#include<vector>
#include<cstdio>
#include<time.h>
using namespace std;
//宏定义
#define mem(x,y) memset(x,y,sizeof(x))
#define pb push_back
const int maxn = 5e5 + 10;//节点最大个数
const int maxm = 5e6 + 10;//询问最大个数
int n, m;//边数和询问数
int ans[maxn];//存储答案
int head_e[maxn * 2];//边的头数组
int edge_tot;//边总数
vector<int>head_q[maxn];//询问的头数组
int query_tot;//询问总数
int father[maxn];//并查集存根节点
bool vis[maxn];//标志节点是否已经搜索过
struct E
{
int to;
int nex;//指向下一个结构体下标
void init()
{
to = 0;
nex = 0;
}
}edge[maxn * 2];//双向边要开两倍
void add_edge(int u, int v)//连边操作,头插的方法
{
edge[edge_tot].to = v;
edge[edge_tot].nex = head_e[u];
head_e[u] = edge_tot++;
edge[edge_tot].to = u;
edge[edge_tot].nex = head_e[v];
head_e[v] = edge_tot++;
}
struct Q
{
int id;
int a, b, c;
int lca;
void init()//初始化结构体
{
id = 0;
a = 0;
b = 0;
c = 0;
lca = -1;
}
}query[maxm];
void add_query(int a, int b, int c, int id)
{
query[query_tot].a = a;
query[query_tot].b = b;
query[query_tot].c = c;
query[query_tot].id = id;
head_q[a].pb(query_tot);//把询问下标放进相关节点的容器,pb是宏定义
head_q[b].pb(query_tot);
head_q[c].pb(query_tot);
query_tot++;
}
int Find(int x)
{
return x == father[x] ? x : father[x] = Find(father[x]);//压缩路径
}
void join(int u, int v)//并查集
{
int fu = Find(u);
int fv = Find(v);
if (fu != fv)//指向父节点
{
father[fv] = fu;
}
}
void LCA(int u, int fa)//处理结果,u表示当前搜索到的节点,fa表示它的父节点
{
for (int i = head_e[u]; i != -1; i = edge[i].nex)
{
int v = edge[i].to;
if (v == fa) continue;//防止双向边的同一条边询问
if (vis[v]) continue;//已经搜索过的就不需要再搜索
LCA(v, u);
join(u, v);//合并处理
}
for (int i = 0; i<head_q[u].size(); i++)//查找于当前节点相关的询问
{
int index = head_q[u][i];//得到询问所在结构体的下标
int id = query[index].id;
if (ans[id] != -1) continue;//已经处理的询问无需再操作
int a = query[index].a;
int b = query[index].b;
int c = query[index].c;
int lca = query[index].lca;
if (vis[a] && !vis[b] && lca == -1)//处理A和B的最近公共祖先
{
query[index].lca = Find(a);
}
if (vis[b] && !vis[a] && lca == -1)//处理A和B的最近公共祖先
{
query[index].lca = Find(b);
}
lca = query[index].lca;
if (vis[a] && vis[b] && u == c&&Find(a) == c&&Find(b) == c) //C是A和B的最近公共祖先或者是A和B的最近公共祖先以上的节点
{
if (c == lca)//C是A和B的最近公共祖先
ans[id] = 1;
else ans[id] = 0;//C不是A和B的最近公共祖先
}
else if (vis[a] && u == c&&Find(a) == c) //C在A的路径上
{
ans[id] = 1;
}
else if (vis[b] && u == c&&Find(b) == c)//c在B的路径上
{
ans[id] = 1;
}
}
vis[u] = true;
}
void init(int n)//每次输入初始化
{
for (int i = 0; i <= n; i++) father[i] = i, head_q[i].clear();
for (int i = 0; i <= maxn; i++) edge[i].init(), query[i].init();
mem(ans, -1);//mem是宏定义
mem(vis, false);
mem(head_e, -1);
edge_tot = 0;
query_tot = 0;
}
int main()
{
clock_t start, finish;//测试运行时间
start = clock();
freopen("input.txt", "r", stdin);//输入数据
freopen("out.txt", "w", stdout);//输出答案
while (~scanf("%d", &n) && n)//波浪号表示是否文件读取结束
{
init(n);//初始化
for (int i = 0; i<n - 1; i++)//连边
{
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++)//添加询问
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add_query(a, b, c, i);
}
LCA(1, -1);//处理过程
for (int i = 1; i <= m; i++)//打印答案
{
if (ans[i] == 1) puts("Yes");
else puts("No");
}
puts("");
}
finish = clock();
cout << ((double)(finish - start) / CLOCKS_PER_SEC) << " (s) " << endl;//打印运行时间
}
树链剖分:
#include<algorithm>
#include<set>
#include<cmath>
#include<cstring>
#include<iostream>
#include<set>
#include<vector>
#include<queue>
#include<cmath>
#include<cstdio>
#include<map>
#include<stack>
#include<bits/stdc++.h>
using namespace std;
#define sfi(i) scanf("%d",&i)
#define sfs(i) scanf("%s",(i))
#define pri(i) printf("%d\n",i)
#define sff(i) scanf("%lf",&i)
#define ll long long
#define ull unsigned long long
#define mem(x,y) memset(x,y,sizeof(x))
#define INF 0x3f3f3f3f
#define eps 1e-16
#define PI acos(-1)
#define lowbit(x) ((x)&(-x))
#define zero(x) (((x)>0?(x):-(x))<eps)
#define fl() printf("flag\n")
#define MOD(x) ((x%mod)+mod)%mod
#define endl '\n'
#define pb push_back
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define FAST_IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
const int maxn=1e6+9;
const int mod=1e9+7;
inline ll read()
{
ll f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9')
{
if(ss=='-')f=-1;ss=getchar();
}
while(ss>='0'&&ss<='9')
{
x=x*10+ss-'0';ss=getchar();
} return f*x;
}
int n,m;
int ans=0;
int a,b,c;
int tot;
int head[maxn];
int rk[maxn],f[maxn],d[maxn],siz[maxn],son[maxn],top[maxn],id[maxn];
int cnt;
struct E
{
int to;
int nex;
}edge[maxn];
void add(int u,int v)
{
edge[tot].to=v;
edge[tot].nex=head[u];
head[u]=tot++;
edge[tot].to=u;
edge[tot].nex=head[v];
head[v]=tot++;
}
void dfs1(int u,int fa,int depth)//当前节点,父节点,深度
{
cout<<u<<endl;
f[u]=fa;
d[u]=depth;
siz[u]=1;//本身是1
for(int i=head[u];i!=-1;i=edge[i].nex)
{
int v=edge[i].to;
if(v==fa) continue;
dfs1(v,u,depth+1);
siz[u]+=siz[v];
if(siz[v]>siz[son[u]])
son[u]=v;
}
}
void dfs2(int u,int t)//当前节点。重链顶端
{
top[u]=t;
id[u]=++cnt;
rk[cnt]=u;
if(!son[u]) return ;
dfs2(son[u],t);
for(int i=head[u];i!=-1;i=edge[i].nex)
{
int v=edge[i].to;
if(v!=son[u]&&v!=f[u])
dfs2(v,v);
}
}
int LCA(int x,int y)
{
for(;top[x]!=top[y];d[top[x]]>d[top[y]]?x=f[top[x]]:y=f[top[y]]);
return d[x]<d[y]?x:y;
}
int main()
{
freopen("data50000.txt","r",stdin);
freopen("out.txt","w",stdout);
for(int i=0;i<=maxn;i++) head[i]=-1;
cin>>n;
for(int i=0;i<n-1;i++)
{
int u,v;
cin>>u>>v;
add(u,v);
}
dfs1(1,0,1);
dfs2(1,1);
cin>>m;
while(m--)
{
cin>>a>>b>>c;
ans=0;
int AB=LCA(a,b);
int AC=LCA(a,c);
int BC=LCA(b,c);
if(AB==c||((AC==c)&&(BC!=c))||((AC!=c)&&(BC==c))) ans=1;
if(ans) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
}
暴力:
#include<algorithm>
#include<set>
#include<cmath>
#include<cstring>
#include<iostream>
#include<set>
#include<vector>
#include<queue>
#include<cmath>
#include<cstdio>
#include<map>
#include<stack>
#include<bits/stdc++.h>
using namespace std;
#define sfi(i) scanf("%d",&i)
#define sfs(i) scanf("%s",(i))
#define pri(i) printf("%d\n",i)
#define sff(i) scanf("%lf",&i)
#define ll long long
#define ull unsigned long long
#define mem(x,y) memset(x,y,sizeof(x))
#define INF 0x3f3f3f3f
#define eps 1e-16
#define PI acos(-1)
#define lowbit(x) ((x)&(-x))
#define zero(x) (((x)>0?(x):-(x))<eps)
#define fl() printf("flag\n")
#define MOD(x) ((x%mod)+mod)%mod
#define endl '\n'
#define pb push_back
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define FAST_IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
const int maxn=1e6+9;
const int mod=1e9+7;
inline ll read()
{
ll f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9')
{
if(ss=='-')f=-1;ss=getchar();
}
while(ss>='0'&&ss<='9')
{
x=x*10+ss-'0';ss=getchar();
} return f*x;
}
int n,m;
int ans=0;
int a,b,c;
int tot;
bool vis[maxn];
int head[maxn];
struct E
{
int to;
int nex;
}edge[maxn];
void add(int u,int v)
{
edge[tot].to=v;
edge[tot].nex=head[u];
head[u]=tot++;
edge[tot].to=u;
edge[tot].nex=head[v];
head[v]=tot++;
}
void dfs(int u,bool fc)
{
if(vis[u]) return ;
if(ans) return ;
//if(u==b) cout<<c<<endl;
if(u==b&&fc)
{
ans=1;
return ;
}
vis[u]=1;
for(int i=head[u];i!=-1;i=edge[i].nex)
{
int v=edge[i].to;
//cout<<v<<endl;
dfs(v,u==c||fc);
}
}
int main()
{
for(int i=0;i<=maxn;i++) head[i]=-1;
cin>>n;
for(int i=0;i<n-1;i++)
{
int u,v;
cin>>u>>v;
add(u,v);
}
cin>>m;
while(m--)
{
mem(vis,0);
cin>>a>>b>>c;
ans=0;
dfs(a,0);
if(ans) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
}