Nearest Common Ancestors
Time Limit: 1000MS   Memory Limit: 10000K
Total Submissions: 19728   Accepted: 10460

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

本题是一个多叉树,然后求两点的近期公共单亲节点。

就是典型的LCA问题。这是一个非常多解法的,并且被研究的非常透彻的问题。

原始的解法:从根节点往下搜索,若果搜索到两个节点分别在一个节点的两边。那么这个点就是近期公共单亲节点了。

Trajan离线算法:首次找到两个节点的时候,假设记录了他们的最低单亲节点,那么答案就是这个最低的单亲节点了。

问题是怎样有效记录这个最低单亲节点,并有效依据遍历的情况更新,这就是利用Union Find(并查集)记录已经找到的节点,并及时更新最新訪问的节点的当前最低单亲节点。

就是并查集的灵活运用啦,假设学会了并查集那么学这个算法是不难的了。

2015-1-24 update:

以下括号的分析好像有点问题:

(以下是简单思路差点儿相同是暴力法的解法,只是事实上相对本题来说就是一次查询,故此这个也是不错的方法,并且平均时间效率只是O(lgn),应该是非常快的了。

只是有思想和这个差点儿相同的。可是更加省内存的方法,就是从须要查找的节点往单亲节点查找,那么速度是一样的,只是省内存,由于仅仅须要记录一个父母节点就能够了。并且程序会简洁点。)

这种方法的基本思想是:

如果要查找u,v的LCA,

递归深度遍历整棵树,这个时候有三种情况:

1. 假设没哟找到u或者v当中一个节点。那么就返回0;

2 假设找到了u或v的当中一个节点。那么就返回找到的节点

3 假设找到u且找到v两个节点。那么就返回其父母节点。而这个父母节点正好是LCA,为什么呢?由于这个是逐层递归上去的算法,仅仅有在u和v的分叉节点能找到两个非零返回值,其它情况都仅仅能找到一个或者0个非零返回值。巧妙地利用了递归的特点。把LCA作为了终于的返回值。

由于最坏情况须要递归整棵树。故此这个算法的时间效率事实上是O(n),n为整棵树的节点数。

故此本算法尽管AC了,可是事实上时间效率还是蛮低的。

之前分析说是O(lgn)是不正确的。不好意思。假设误导了某些读者,那么表示抱歉。

还好以下算法是没错的。

本算法对递归的理解还是要求挺高的,对于刚開始学习的人还是有点难度。

int const MAX_N = 10001;

struct Node
{
bool notRoot;
vector<int> children;
}; Node Tree[MAX_N];
int N; int find(int r, int lNode, int rNode)
{
if (!r) return 0;
if (r == lNode) return r;
if (r == rNode) return r; vector<int> found;
for (int i = 0; i < (int)Tree[r].children.size(); i++)
{
found.push_back(find(Tree[r].children[i], lNode, rNode));
}
int u = 0, v = 0;
for (int i = 0; i < (int)found.size(); i++)
{
if (found[i] != 0)
{
if (u) v = found[i];
else u = found[i];
}
}
if (v) return r;
return u;
} void solve()
{
scanf("%d", &N);
memset(Tree, 0, sizeof(Tree)); int u, v;
for (int i = 1; i < N; i++)
{
scanf("%d %d", &u, &v);
Tree[u].children.push_back(v);
Tree[v].notRoot = 1;
}
int root = 0;
for (int i = 1; i <= N; i++)
{
if (!Tree[i].notRoot)
{
root = i;
break;
}
} scanf("%d %d", &u, &v);
int r = find(root, u, v);
printf("%d\n", r);//if (lin && rin) 必定是存在点。故此无需推断
} int main()
{
int T;
scanf("%d", &T);
while (T--)
{
solve();
}
return 0;
}

以下是Tarjan离线算法,效率应该和上面是一样的。多次查询的时候就能提高效率。只是实际执行比上面快。

#include <stdio.h>
#include <string.h>
#include <vector>
using std::vector;
int const MAX_N = 10001; struct Node
{
bool notRoot;
bool vis;
vector<int> children;
}; Node Tree[MAX_N];
int N;
int u, v;
int parent[MAX_N]; inline int find(int x)
{
if (!parent[x]) return x;
return parent[x] = find(parent[x]);
} inline void unionTwo(int p, int x)
{
p = find(p);
x = find(x);
if (p == x) return ;
parent[x] = p;
} bool LCATarjan(int root)
{
Tree[root].vis = true;
if (root == u && Tree[v].vis == true)
{
printf("%d\n", find(v));
return true;
}
if (root == v && Tree[u].vis == true)
{
printf("%d\n", find(u));
return true;
}
for (int i = 0; i < (int)Tree[root].children.size(); i++)
{
if (LCATarjan(Tree[root].children[i])) return true;
unionTwo(root, Tree[root].children[i]);
}
return false;
} void solve()
{
scanf("%d", &N);
memset(Tree, 0, sizeof(Tree));
memset(parent, 0, sizeof(parent)); for (int i = 1; i < N; i++)
{
scanf("%d %d", &u, &v);
Tree[u].children.push_back(v);
Tree[v].notRoot = 1;
}
int root = 0;
for (int i = 1; i <= N; i++)
{
if (!Tree[i].notRoot)
{
root = i;
break;
}
}
scanf("%d %d", &u, &v);
LCATarjan(root);
} int main()
{
int T;
scanf("%d", &T);
while (T--)
{
solve();
}
return 0;
}

POJ 1330 Nearest Common Ancestors LCA题解的更多相关文章

  1. POJ.1330 Nearest Common Ancestors (LCA 倍增)

    POJ.1330 Nearest Common Ancestors (LCA 倍增) 题意分析 给出一棵树,树上有n个点(n-1)条边,n-1个父子的边的关系a-b.接下来给出xy,求出xy的lca节 ...

  2. poj 1330 Nearest Common Ancestors lca 在线rmq

    Nearest Common Ancestors Description A rooted tree is a well-known data structure in computer scienc ...

  3. poj 1330 Nearest Common Ancestors LCA

    题目链接:http://poj.org/problem?id=1330 A rooted tree is a well-known data structure in computer science ...

  4. POJ 1330 Nearest Common Ancestors (LCA,倍增算法,在线算法)

    /* *********************************************** Author :kuangbin Created Time :2013-9-5 9:45:17 F ...

  5. POJ 1330 Nearest Common Ancestors(LCA模板)

    给定一棵树求任意两个节点的公共祖先 tarjan离线求LCA思想是,先把所有的查询保存起来,然后dfs一遍树的时候在判断.如果当前节点是要求的两个节点当中的一个,那么再判断另外一个是否已经访问过,如果 ...

  6. POJ - 1330 Nearest Common Ancestors(基础LCA)

    POJ - 1330 Nearest Common Ancestors Time Limit: 1000MS   Memory Limit: 10000KB   64bit IO Format: %l ...

  7. POJ 1330 Nearest Common Ancestors / UVALive 2525 Nearest Common Ancestors (最近公共祖先LCA)

    POJ 1330 Nearest Common Ancestors / UVALive 2525 Nearest Common Ancestors (最近公共祖先LCA) Description A ...

  8. POJ 1330 Nearest Common Ancestors(lca)

    POJ 1330 Nearest Common Ancestors A rooted tree is a well-known data structure in computer science a ...

  9. POJ 1330 Nearest Common Ancestors 倍增算法的LCA

    POJ 1330 Nearest Common Ancestors 题意:最近公共祖先的裸题 思路:LCA和ST我们已经很熟悉了,但是这里的f[i][j]却有相似却又不同的含义.f[i][j]表示i节 ...

随机推荐

  1. js 时间戳转换成时间格式,可自定义格式

    由于 c# 通过ajax获取的时间 传到前台 格式为:/Date(1354116249000)/ 所以需要转换一下,想要什么格式 更改 format() 里的 返回语句 就可以了 formatDate ...

  2. ExtJs005继承

    Ext.onReady(function () { //extend 继承 Ext.define('Person', { config: { name: 'aaa' }, //给当前定义的类加一个构造 ...

  3. 怎样用Excel自动排成绩

    经常需要做表格,排成绩名次总是笨笨的一个一个填,费时又费力,终于找到了解决的办法%>_<%(不要嘲笑我了(✿◡‿◡)),原来就是一个名叫RANK的函数,还在苦逼地自己输的小伙伴们,快来看吧 ...

  4. 常用类库之.NET中的字符串

    字符串的特性 .不可变性 由于字符串是不可变的的,每次修改字符串,都是创建了一个单独字符串副本(拷贝了一个字符串副本).之所以发生改变只是因为指向了一块新的地址. .字符串池(只针对字符串常量) 当一 ...

  5. js正则语法

    整数或者小数:^[0-9]+\.{0,1}[0-9]{0,2}$只能输入数字:"^[0-9]*$".只能输入n位的数字:"^\d{n}$".只能输入至少n位的数 ...

  6. javascript 原型 和 原型链

    最近几天,好些新同事来问原型,原型链啥的.本身作为菜鸟的我好像也没有好好整理过这个,这里写写自己的理解. 原型 大家都知道,JavaScript 不包含传统的类继承模型,而是使用 prototype ...

  7. 一个最简的 USB Audio 示例

    经过了两三个月的痛苦,USB 协议栈的 Audio Device Class 框架已具雏形了,用了两三天时间,使用这个框架实战了一个基于新唐 M0 的最简单的 USB Audio 程序,可以作为 US ...

  8. [置顶] LED办公楼宇照明节能方案及城市夜景照明节能方案

    LED照明办公楼宇节能方案 .通用标准灯头,可直接替换现有卤素灯.白炽灯.荧光灯.

  9. C++模板:ST算法

    //初始化 void init_rmq(int n){ for(int i=0;i<n;i++)d[i][0]=a[i]; for(int j=1;(1<<j)<=n;j++) ...

  10. Convert Sorted List to Binary Search Tree ------C++ 递归创建平衡二叉查找树

    有序链表 0->1->2->3->4->5 转换为一个二叉排序树.我们在此创建一个平衡二叉排序树 1.先找链表到中间的节点 2.中间节点的val创建一个新的树节点Tree ...