POJ 1330 Nearest Common Ancestors(最近公共祖先 Tarjan离线)

题目链接:http://poj.org/problem?id=1330

题目:

Description

A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:

 
In the figure, each node is labeled with an integer from {1, 2,...,16}. Node 8 is the root of the tree. Node x is an ancestor of node y if node x is in the path between the root and node y. For example, node 4 is an ancestor of node 16. Node 10 is also an ancestor of node 16. As a matter of fact, nodes 8, 4, 10, and 16 are the ancestors of node 16. Remember that a node is an ancestor of itself. Nodes 8, 4, 6, and 7 are the ancestors of node 7. A node x is called a common ancestor of two different nodes y and z if node x is an ancestor of node y and an ancestor of node z. Thus, nodes 8 and 4 are the common ancestors of nodes 16 and 7. A node x is called the nearest common ancestor of nodes y and z if x is a common ancestor of y and z and nearest to y and z among their common ancestors. Hence, the nearest common ancestor of nodes 16 and 7 is node 4. Node 4 is nearer to nodes 16 and 7 than node 8 is.

For other examples, the nearest common ancestor of nodes 2 and 3 is node 10, the nearest common ancestor of nodes 6 and 13 is node 8, and the nearest common ancestor of nodes 4 and 12 is node 4. In the last example, if y is an ancestor of z, then the nearest common ancestor of y and z is y.

Write a program that finds the nearest common ancestor of two distinct nodes in a tree.

Input

The input consists of T test cases. The number of test cases (T) is given in the first line of the input file. Each test case starts with a line containing an integer N , the number of nodes in a tree, 2<=N<=10,000. The nodes are labeled with integers 1, 2,..., N. Each of the next N -1 lines contains a pair of integers that represent an edge --the first integer is the parent node of the second integer. Note that a tree with N nodes has exactly N - 1 edges. The last line of each test case contains two distinct integers whose nearest common ancestor is to be computed.

Output

Print exactly one line for each test case. The line should contain the integer that is the nearest common ancestor.

Sample Input

2
16
1 14
8 5
10 16
5 9
4 6
8 4
4 10
1 13
6 15
10 11
6 7
10 2
16 3
8 1
16 12
16 7
5
2 3
3 4
3 1
1 5
3 5

Sample Output

4
3

Source

题意:最近公共祖先

题解:裸题

 1 #include <vector>
 2 #include <cstdio>
 3 #include <cstring>
 4 using namespace std;
 5
 6 const int N=12345;
 7 int fa[N],ans;
 8 vector <int> E[N];
 9 vector <int> q[N];
10 bool root[N],vis[N];
11
12 void init(){
13     for(int i=0;i<N;i++){
14         fa[i]=i;
15         E[i].clear();
16         q[i].clear();
17         vis[i]=false;
18         root[i]=true;
19     }
20 }
21
22 int Find(int x){
23     return fa[x]==x?x:fa[x]=Find(fa[x]);
24 }
25
26 void Union(int x,int y){
27     int fx=Find(x),fy=Find(y);
28     if(fx!=fy){
29         fa[fy]=fx;
30     }
31 }
32
33 void solve(int u){
34     vis[u]=1;
35     for(int i=0;i<E[u].size();i++){
36         int v=E[u][i];
37         if(vis[v]) continue;
38         solve(v);
39         Union(u,v);
40     }
41     for(int i=0;i<q[u].size();i++){
42         int v=q[u][i];
43         if(!vis[v]) continue;
44         ans=Find(v);
45     }
46 }
47
48 int main(){
49     int t,n;
50     scanf("%d",&t);
51     while(t--){
52         init();
53         int u,v;
54         scanf("%d",&n);
55         for(int i=1;i<n;i++){
56             scanf("%d%d",&u,&v);
57             E[u].push_back(v);
58             root[v]=false;
59         }
60         scanf("%d%d",&u,&v);
61         q[u].push_back(v);
62         q[v].push_back(u);
63         for(int i=1;i<=n;i++){
64             if(root[i]) {solve(i);break;}
65         }
66         printf("%d\n",ans);
67     }
68     return 0;
69 }

原文地址:https://www.cnblogs.com/Leonard-/p/8732927.html

时间: 2024-10-15 15:10:30

POJ 1330 Nearest Common Ancestors(最近公共祖先 Tarjan离线)的相关文章

POJ - 1330 Nearest Common Ancestors 最近公共祖先+链式前向星 模板题

A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:  In the figure, each node is labeled with an integer from {1, 2,...,16}. Node 8 is the root of the tree. Node x is an ancestor of node y if n

POJ 1330 Nearest Common Ancestors 最近公共祖先

LCA模板题,用倍增法去写 首先把每一个节点的向上\(2^i (i \in \mathbb N)\)个祖先给枚举出来 再把要求公共祖先的两个节点拉到同一深度 向上不断利用倍增一起跳跃同样层数到他们各自的非公共祖先的祖先节点 最后他们一起到达共同祖先节点的子节点,再同时向上走一位即可 在这个过程中,同时维护cost即可 #include<bits/stdc++.h> using namespace std; typedef long long ll; typedef unsigned long

POJ 1330 Nearest Common Ancestors (最近公共祖先LCA + 详解博客)

LCA问题的tarjan解法模板 LCA问题 详细 1.二叉搜索树上找两个节点LCA 1 public int query(Node t, Node u, Node v) { 2 int left = u.value; 3 int right = v.value; 4 5 //二叉查找树内,如果左结点大于右结点,不对,交换 6 if (left > right) { 7 int temp = left; 8 left = right; 9 right = temp; 10 } 11 12 whi

POJ 1330 Nearest Common Ancestors 倍增算法的LCA

POJ 1330 Nearest Common Ancestors 题意:最近公共祖先的裸题 思路:LCA和ST我们已经很熟悉了,但是这里的f[i][j]却有相似却又不同的含义.f[i][j]表示i节点的第2j个父亲是多少   这个代码不是我的,转自 邝斌博客 1 /* *********************************************** 2 Author :kuangbin 3 Created Time :2013-9-5 9:45:17 4 File Name :F

POJ 1330 Nearest Common Ancestors LCA(在线RMQ,离线Tarjan)

链接:http://poj.org/problem?id=1330 题意:只看题目就知道题目是什么意思了,最近公共祖先,求在一棵树上两个节点的最近公共祖先. 思路:求最近公共祖先有两种算法,在线和离线,在线方法是用RMQ求LCA,一句话总结就是在从DFS时,从第一个点到第二个点的最短路径中深度最浅的点就是公共祖先,用RMQ处理,一般问题的最优解决方式的复杂度是O(NlogN)的预处理+N*O(1)的查询.离线方法是Tarjan算法,将所有询问的两个点都记录下来,在DFS过程中不断将每个点自身作为

[POJ 1330] Nearest Common Ancestors (朴素方法)

POJ 1330: Nearest Common Ancestors Time Limit: 1000ms Memory Limit: 32Mb Description A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:  In the figure, each node is labeled with an integer fro

POJ - 1330 Nearest Common Ancestors(基础LCA)

POJ - 1330 Nearest Common Ancestors Time Limit: 1000MS   Memory Limit: 10000KB   64bit IO Format: %lld & %llu Submit Status Description A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:  In t

POJ 1330 Nearest Common Ancestors LCA题解

本题是一个多叉树,然后求两点的最近公共单亲节点. 就是典型的LCA问题.这是一个很多解法的,而且被研究的很透彻的问题. 原始的解法:从根节点往下搜索,若果搜索到两个节点分别在一个节点的两边,那么这个点就是最近公共单亲节点了. Trajan离线算法:首次找到两个节点的时候,如果记录了他们的最低单亲节点,那么答案就是这个最低的单亲节点了. 问题是如何有效记录这个最低单亲节点,并有效根据遍历的情况更新,这就是利用Union Find(并查集)记录已经找到的节点,并及时更新最新访问的节点的当前最低单亲节

POJ 1330 Nearest Common Ancestors(树)

Nearest Common Ancestors Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 17628   Accepted: 9335 Description A rooted tree is a well-known data structure in computer science and engineering. An example is shown below: In the figure, each

poj 1330 Nearest Common Ancestors

题目连接 http://poj.org/problem?id=1330 Nearest Common Ancestors Description A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:  In the figure, each node is labeled with an integer from {1, 2,...,