数据结构课程设计-神秘国度的爱情故事-LCA：tarjan+离线/树链剖分/暴力

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_backconst 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;//本身是1for(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;}
}

数据结构课程设计-神秘国度的爱情故事-LCA：tarjan+离线/树链剖分/暴力相关推荐

数据结构课程设计神秘国度的爱情故事
数据结构课程设计报告广州大学计算机科学与网络工程学院计算机系 17级计科专业2班 2019年6月30日广州大学学生实验报告开课学院及实验室:计算机科学与工程实验室 ...
【广州大学】数据结构课程设计：神秘国度的爱情故事
数据结构课程设计报告广州大学计算机科学与网络工程学院计算机系 19级网络工程专业网络194班超级菜狗 (学号:19062000) (班内序号:xxx) 完成时间:2021年1月11日一．课程 ...
神秘国度的爱情故事——广州大学课程设计
神秘国度的爱情故事 [问题描述] 某个太空神秘国度中有很多美丽的小村,从太空中可以想见,小村间有路相连,更精确一点说,任意两村之间有且仅有一条路径.小村 A 中有位年轻人爱上了自己村里的美丽姑娘.每天 ...
神秘国度的爱情故事数据结构课设-广州大学
神秘国度的爱情故事数据结构课设-广州大学 ps:本次课设程序不仅需要解决问题,更需要注重代码和算法的优化和数据测试分析直接广度优先实现的方法时间复杂度为O(QN),优化后的方法是lca+ ...
神秘国度的爱情故事--数据结构课程设计
结论:最开始N个结点的树,处理M组数据,采用深度优先搜索,总时间复杂度为O(NM).优化方法是找最近公共祖先(lca)的倍增法.N个结点的树,每次找最近公共祖先的时间复杂度为O(logN),处理M组数 ...
数据结构课程设计——机票售卖系统（C++）
引言这学期最后的数据结构课程设计需要我们完成一个简单的小程序,我选择了一个机票售卖系统,实现了一些基本的功能:因为时间给的比较短,又赶在复习周补课,所以并没有什么突出的地方,我就在这里聊聊我的代码实 ...
数据结构课程设计---最长公共子串
数据结构课程设计,由用户输入两个字符串串X和Y,再由用户输入一个任意的字符串Z,实现以下功能: ①如果字符串Z是字符串X的子串,则显示Z在X中的位置并记录,如果字符串Z是字符串Y的子串,则显示Z在Y中 ...
设树采用孩子兄弟表示法存放.用类c语言设计算法计算树的高度.,(数据结构课程设计分类题目.doc...
(数据结构课程设计分类题目线性表顺序表: 1.设有一元素为整数的线性表L=(a1,a2,a3,-,an),存放在一维数组A[N]中,设计一个算法,以表中an作为参考元素,将该表分为左.右两部分,其 ...
c语言数据结构五子棋实验报告,数据结构课程设计-五子棋
数据结构课程设计-五子棋姓名: 学院: 计算机与通信学院班级: 通信工程 101 班指导老师: 目录一.需求分析 31.1 开发背景 .32.2 功能简介 .3二.系统设计 42.1 函数 ...

数据结构课程设计-神秘国度的爱情故事-LCA：tarjan+离线/树链剖分/暴力

数据结构课程设计-神秘国度的爱情故事-LCA：tarjan+离线/树链剖分/暴力相关推荐

最新文章

热门文章