LCA的两种求法

HDU 2586 

题意：一棵树，多次询问任意两点的路径长度。

LCA：最近公共祖先Least Common Ancestors。两个节点向根爬，第一个碰在一起的结点。

求出x, y的最近公共祖先lca后，假设dist[x]为x到根的距离，那么x->y的距离为dist[x]+dist[y]-2*dist[lca]

求最近公共祖先解法常见的有两种

1, tarjan+并查集

2,树上倍增

首先是树上倍增。

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int maxn = 4e4 + 7;

int T, n, m, u, v, w;

int first[maxn], sign, st[maxn][21], level[maxn], dist[maxn];

struct Node {
    int to, w, next;
} edge[maxn * 2];

inline void init() {
    for(int i = 0; i <= n; i ++ ) {
        first[i] = -1;
    }
    sign = 0;
}

inline void add_edge(int u, int v, int w) {
    edge[sign].to = v;
    edge[sign].w = w;
    edge[sign].next = first[u];
    first[u] = sign ++;
}

void dfs(int now, int father) {
    level[now] = level[father] + 1;
    st[now][0] = father;
    for(int i = 1; (1 << i) <= level[now]; i ++ ) {
        st[now][i] = st[ st[now][i - 1] ][i - 1];
    }
    for(int i = first[now]; ~i; i = edge[i].next) {
        int to = edge[i].to, w = edge[i].w;
        if(to == father) {
            continue;
        }
        dist[to] = dist[now] + w;
        dfs(to, now);
    }
}

int LCA(int x, int y) {
    if(level[x] > level[y]) {
        swap(x, y);
    }
    for(int i = 20; i >= 0; i -- ) {
        if(level[x] + (1 << i) <= level[y]) {
            y = st[y][i];
        }
    }
    if(x == y) {
        return x;
    }
    for(int i = 20; i >= 0; i -- ) {
        if(st[x][i] == st[y][i]) {
            continue;
        } else {
            x = st[x][i], y = st[y][i];
        }
    }
    return st[x][0];
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        init();
        for(int i = 1; i <= n - 1; i ++ ) {
            scanf("%d %d %d", &u, &v, &w);
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
        memset(level, 0, sizeof(level));
        memset(st, 0, sizeof(st));
        dist[1] = 0;
        dfs(1, 0);
        for(int i = 1; i <= m; i ++ ) {
            int u, v;
            scanf("%d %d", &u, &v);
            int lca = LCA(u, v);
            printf("%d
", dist[u] + dist[v] - 2 * dist[lca]);
        }
    }

    return 0;
}

然后是tarjan的解法(参考算法竞赛进阶指南)

个人理解，tarjan算法就是对搜索的过程中维护了一些性质。在搜索的过程中把点分为三类

1,已经范围且回溯的点，代码中vis[x]=2

2,已经访问还没有回溯的点,代码中vis[x]=1

3,未被标记的点

每一个回溯的点都用并查集连到他的父节点，这样如果我们x点正在访问，我们需要知道x,y的lca,而y已经被访问了，那么并查集y的根就是x,y的lca

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int MAXN = 5e4 + 7;
const int INF = 0x3f3f3f3f;

int n, m, first[MAXN], sign;

int pre[MAXN], ans[MAXN], vis[MAXN], dist[MAXN], lca[MAXN], indexs;

vector<pair<int, int> >query[MAXN]; ///y, id

struct Node {
    int to, w, next;
} edge[MAXN * 2];

inline void init() {
    for(int i = 0; i <= n; i++ ) {
        first[i] = -1;
        pre[i] = i;
        query[i].clear();
        ans[i] = INF;
        vis[i] = 0;
    }
    sign = 0;
}

inline void add_edge(int u, int v, int w) {
    edge[sign].to = v;
    edge[sign].w = w;
    edge[sign].next = first[u];
    first[u] = sign++;
}

int findx(int x) {
    return pre[x] == x ? x : pre[x] = findx(pre[x]);
}

inline void join(int x, int y) {
    int fx = findx(x), fy = findx(y);
    pre[fx] = fy;
}

inline bool same(int x, int y) {
    return findx(x) == findx(y);
}

void tarjan(int now) {
    vis[now] = 1;
    for(int i = first[now]; ~i; i = edge[i].next) {
        int to = edge[i].to;
        if(!vis[to]) {
            dist[to] = dist[now] + edge[i].w;
            tarjan(to);
            pre[to] = now;
        }
    }
    for(int i = 0; i < query[now].size(); i++ ) {
        int y = query[now][i].first, id = query[now][i].second;
        if(vis[y] == 2) {
            int lca = findx(y);
            ans[id] = min(ans[id], dist[now] + dist[y] - 2 * dist[lca]);
        }
    }
    vis[now] = 2;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        init();
        for(int i = 1; i <= n - 1; i++ ) {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            add_edge(u, v, w);
            add_edge(v, u, w);
        }
        for(int i = 1; i <= m; i++ ) {
            int x, y;
            scanf("%d %d", &x, &y);
            if(x == y) {
                ans[i] = 0;
                continue;
            }
            query[x].push_back(make_pair(y, i));
            query[y].push_back(make_pair(x, i));
            ans[i] = INF;
        }
        tarjan(1);
        for(int i = 1; i <= m; i++ ) {
            printf("%d
", ans[i]);
        }
    }
    return 0;
}