【LCA|Tarjan】POJ-1330 Nearest Common Ancestors

Nearest Common Ancestors

Time Limit: 1000MS Memory Limit: 10000K

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

Taejon 2002



题意: T组数据,每组数据给出N个点和N-1条边,每条边先给出父结点,最后一行查询一对结点,输出它们的最近公共祖先。

思路: 因为只有一个询问,所以对输出顺序没有要求。可以使用离线的Tarjan算法(dfs+并查集)来解决此题。

图片来自hihoCoder

建树完成之后,找到root,开始dfs,每dfs到一个点的时候,例如u,将其祖先1标记为u(这个时候u结点还没有处理完毕,我们称之为灰色结点,相应的,没有遍历到的结点称为白色结点,处理完毕的结点称之为黑色结点),然后遍历它的儿子。如上图的D结点,它的儿子C结点处理完毕之后,将C子树和D结点并为同一个集合(拥有相同的fa[]:D),然后将该集合的祖先标记为D2。

回溯到D之后(子树C的遍历结束后)才算做处理完了C点,vis标记一下3。这个时候进入D的最后一个儿子B。继续向下直到A结点,因为A结点没有儿子,因此直接成为黑色结点。此时遍历A所关联的查询,例如A和C的lca,这个时候C是黑色的,则可以断定答案就是C所在集合的祖先(C上面的第一个灰色结点D,C的祖先之一)了。再例如A和B的lca,这个时候B是灰色,因此一直要回溯到D(子树B被染成黑色),遍历B所关联的查询的时候发现A是黑色结点4。

综上所述,应该可以理解到Tarjan之所以离线的原因了。它是先储存所有的询问,然后在一次dfs的过程中,利用并查集(维护灰色)和dfs序(维护黑色和白色)“顺便”求出lca的。

代码如下

/*
 * ID: j.sure.1
 * PROG:
 * LANG: C++
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <climits>
#include <iostream>
#define PB push_back
#define LL long long
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
/****************************************/
const int N = 1e4 + 5, M = 2e4 + 5;
struct Edge {
    int v, next;
    Edge(){}
    Edge(int _v, int _next):
        v(_v), next(_next){}
}e[M];
int head[N], tot, fa[N];
int n, x, y, anc[N];
bool vis[N], son[N];
vector <int> Q[N];

void init()
{
    memset(head, -1, sizeof(head));
    tot = 0;
    for(int i = 1; i <= n; i++) fa[i] = i;
    memset(vis, 0, sizeof(vis));
    memset(son, 0, sizeof(son));
    memset(anc, 0, sizeof(anc));
    for(int i = 1; i <= n; i++) Q[i].clear();
}

void add(int u, int v)
{
    e[tot] = Edge(v, head[u]);
    head[u] = tot++;
}

int Find(int x)
{
    if(x != fa[x]) return fa[x] = Find(fa[x]);
    return x;
}

void Union(int x, int y)
{
    int fx = Find(x), fy = Find(y);
    if(fy != fx) fa[fy] = fx;
}

void dfs(int u)
{
    anc[u] = u;
    for(int i = head[u]; ~i; i = e[i].next) {
        int v = e[i].v;
        dfs(v);
        Union(u, v);
        anc[Find(u)] = u;
    }
    vis[u] = true;
    int sz = Q[u].size();
    for(int i = 0; i < sz; i++) {
        int v = Q[u][i];
        if(vis[v]) {
            printf("%d\n", anc[Find(v)]);
            return ;
        }
    }
}

int main()
{
#ifdef J_Sure
    freopen("000.in", "r", stdin);
    //freopen("999.out", "w", stdout);
#endif
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        int u, v;
        init();
        for(int i = 0; i < n-1; i++) {
            scanf("%d%d", &u, &v);
            add(u, v);
            son[v] = true;
        }
        int root;
        for(int i = 1; i <= n; i++) {
            if(!son[i]) {
                root = i;
                break;
            }
        }
        scanf("%d%d", &x, &y);
        Q[x].push_back(y);
        Q[y].push_back(x);
        dfs(root);
    }
    return 0;
}

  1. 祖先数组anc只是一个临时数组,用来存放此时某结点向上的第一个灰色结点,也就是集合的fa[]。 ?
  2. 祖先标记为u意即染上u的颜色。此时这个集合都是灰色的。 ?
  3. vis = 1意即回溯完毕,尽管暂时还没有退出整个dfs,但是下面的函数仅仅是处理查询,因此可以当作处理完毕。 ?
  4. 因此对于每个查询我们需要添加x-y意即y-x这两条边,防止遗漏。 ?
时间: 2024-11-05 10:46:26

【LCA|Tarjan】POJ-1330 Nearest Common Ancestors的相关文章

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 LCA题解

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

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

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 (朴素方法)

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(树)

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,...,

POJ 1330 Nearest Common Ancestors 【最近公共祖先LCA算法+Tarjan离线算法】

Nearest Common Ancestors Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 20715   Accepted: 10910 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 【LCA】

Nearest Common Ancestors Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 20073   Accepted: 10631 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 lca 在线rmq

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,...,16}. Node 8 is the root of the tree.