最近公共祖先LCA：Tarjan 算法

Smile3 — Sat, 23 Jul 2011 13:08:00 GMT

这篇博客写的非常不错，我就是看这个学会的。

第一次写最近公共祖先问题，用的邻接表指针。

对于一棵有根树，就会有父亲结点，祖先结点，当然最近公共祖先就是这两个点所有的祖先结点中深度最大的一个结点。

/ \

2 3

比如说在这里，如果0为根的话，那么1是2和3的父亲结点，0是1的父亲结点，0和1都是2和3的公共祖先结点，但是1才是最近的公共祖先结点，或者说1是2和3的所有祖先结点中距离根结点最远的祖先结点。

在求解最近公共祖先为问题上，用到的是Tarjan的思想，从根结点开始形成一棵深搜树，非常好的处理技巧就是在回溯到结点u的时候，u的子树已经遍历，这时候才把u结点放入合并集合中，这样u结点和所有u的子树中的结点的最近公共祖先就是u了，u和还未遍历的所有u的兄弟结点及子树中的最近公共祖先就是u的父亲结点。以此类推。。这样我们在对树深度遍历的时候就很自然的将树中的结点分成若干的集合，两个集合中的所属不同集合的任意一对顶点的公共祖先都是相同的，也就是说这两个集合的最近公共最先只有一个。对于每个集合而言可以用并查集来优化，时间复杂度就大大降低了，为O(n + q)，n为总结点数，q为询问结点对数。

另外Tarjan解法，是一个离线算法，就是说它必须将所有询问先记录下来，再一次性的求出每个点对的最近公共祖先，只有这样才可以达到降低时间复杂度。另外还有一个在线算法，有待学习，呵呵。。

//parent为并查集，FIND为并查集的查找操作
//QUERY为询问结点对集合
//TREE为基图有根树
 Tarjan(u)
      visit[u] = true
      for each (u, v) in QUERY
          if visit[v]
              ans(u, v) = FIND(v)
      for each (u, v) in TREE    
          if !visit[v]
              Tarjan(v)
              parent[v] = u

hdu2586 How far away ？

这道题题意是，给定一棵树，每条边都有一定的权值，q次询问，每次询问某两点间的距离。这样就可以用LCA来解，首先找到u, v 两点的lca，然后计算一下距离值就可以了。这里的计算方法是，记下根结点到任意一点的距离dis[]，这样ans = dis[u] + dis[v] - 2 * dis[lca(v, v)]了，这个表达式还是比较容易理解的。。

代码

//============================================================================
// Name        : hdu2586.cpp
// Author      : birdfly
// Description : 最近公共祖先
//============================================================================

#include <iostream>
#include <string.h>
#include <stdio.h>
#define NN 40002 // number of house
#define MM 202   // number of query
using namespace std;

typedef struct node{
    int v;
    int d;
    struct node *nxt;
}NODE;

NODE *Link1[NN];
NODE edg1[NN * 2]; // 树中的边

NODE *Link2[NN];
NODE edg2[NN * 2]; // 询问的点对

int idx1, idx2, N, M;
int res[MM][3]; // 记录结果，res[i][0]: u   res[i][1]: v  res[i][2]: lca(u, v)
int fat[NN];
int vis[NN];
int dis[NN];

void Add(int u, int v, int d, NODE edg[], NODE *Link[], int &idx){
    edg[idx].v = v;
    edg[idx].d = d;
    edg[idx].nxt = Link[u];
    Link[u] = edg + idx++;

    edg[idx].v = u;
    edg[idx].d = d;
    edg[idx].nxt = Link[v];
    Link[v] = edg + idx++;
}

int find(int x){ // 并查集路径压缩
 if(x != fat[x]){
        return fat[x] = find(fat[x]);
    }
    return x;
}

void Tarjan(int u){
    vis[u] = 1;
    fat[u] = u;

    for (NODE *p = Link2[u]; p; p = p->nxt){
        if(vis[p->v]){
            res[p->d][2] = find(p->v); // 存的是最近公共祖先结点
        }
    }

    for (NODE *p = Link1[u]; p; p = p->nxt){
        if(!vis[p->v]){
            dis[p->v] = dis[u] + p->d;
            Tarjan(p->v);
            fat[p->v] = u;
        }
    }
}
int main() {
    int T, i, u, v, d;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &N, &M);

        idx1 = 0;
        memset(Link1, 0, sizeof(Link1));
        for (i = 1; i < N; i++){
            scanf("%d%d%d", &u, &v, &d);
            Add(u, v, d, edg1, Link1, idx1);
        }

        idx2 = 0;
        memset(Link2, 0, sizeof(Link2));
        for (i = 1; i <= M; i++){
            scanf("%d%d", &u, &v);
            Add(u, v, i, edg2, Link2, idx2);
            res[i][0] = u;
            res[i][1] = v;
        }

        memset(vis, 0, sizeof(vis));
        dis[1] = 0;
        Tarjan(1);

        for (i = 1; i <= M; i++){
            printf("%d\n", dis[res[i][0]] + dis[res[i][1]] - 2 * dis[res[i][2]]);
        }
    }
    return 0;
}

poj1470 Closest Common Ancestors

这道题和上面那道一样，很典型的LCA问题，不过读入有点麻烦，求的是每个点被作为最近公共祖先的次数，呵呵。。

代码

//============================================================================
// Name        : poj1470.cpp
// Author      : birdfly
// Description : 最近公共祖先
//============================================================================

#include <iostream>
#include <stdio.h>
#include <string.h>
#define NN 902
using namespace std;

typedef struct node{
    int v;
    struct node *nxt;
}NODE;

NODE edg1[NN * 2], edg2[NN * 1000];//数组要开大点
NODE *Link1[NN], *Link2[NN];

int idx1, idx2, N, M;
int fat[NN];
int vis[NN];
int cnt[NN];

void Init(NODE *Link[], int &idx){
    memset(Link, 0, sizeof(Link[0]) * (N + 1));
    idx = 0;
}

void Add(int u, int v, NODE edg[], NODE *Link[], int & idx){
    edg[idx].v = v;
    edg[idx].nxt = Link[u];
    Link[u] = edg + idx++;
    edg[idx].v = u;
    edg[idx].nxt = Link[v];
    Link[v] = edg + idx++;
}

int find(int x){
    if(x != fat[x]){
        return fat[x] = find(fat[x]);
    }
    return x;
}

void Tarjan(int u){
    vis[u] = 1;
    fat[u] = u;
    for (NODE *p = Link2[u]; p; p = p->nxt){
        if(vis[p->v]){
            cnt[find(p->v)]++;
        }
    }

    for (NODE *p = Link1[u]; p; p = p->nxt){
        if(!vis[p->v]){
            Tarjan(p->v);
            fat[p->v] = u;
        }
    }
}
int main() {
    int i, u, v, n, root;
    int flag[NN];
    while(scanf("%d", &N) != EOF){

        Init(Link1, idx1);
        memset(flag, 0, sizeof(flag));
        for (i = 1; i <= N; i++){ //数据的读入方式很不错啊
            scanf("%d", &u);
            while(getchar() != '(');
            scanf("%d", &n);
            while(getchar() != ')');
            while(n--){
                scanf("%d", &v);
                flag[v] = 1;
                Add(u, v, edg1, Link1, idx1);
            }
        }
        scanf("%d", &M);
        Init(Link2, idx2);
        for (i = 1; i <= M; i++){
            while(getchar() != '(');
            scanf("%d%d", &u, &v);
            while(getchar() != ')');
            Add(u, v, edg2, Link2, idx2);
        }

        memset(vis, 0, sizeof(vis));
        memset(cnt, 0, sizeof(cnt));

        for (i = 1; i <= N; i++){// 第一个结点不一定是根结点
 if(flag[i] == 0) break;
        }
        root = i; 
        Tarjan(root);

        for (i = 1; i <= N; i++){
            if(cnt[i]){
                printf("%d:%d\n", i, cnt[i]);
            }
        }
    }
    return 0;
}

Smile3 2011-07-23 21:08 发表评论

C++博客-Smile-文章分类-博文

最近公共祖先LCA：Tarjan 算法