数据结构课程设计-神秘国度的爱情故事-LCA：tarjan+离线/树链剖分/暴力_输入要求:输入由若干组测试数据组成。每组数据的第1行包含一正整数n(1≤n≤50-CSDN博客

本文链接：https://blog.csdn.net/weixin_39132605/article/details/91896157

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;
    }
}