【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这两条边，防止遗漏。 ↩