LCA 最近公共祖先(模板) HDU2586 离线与在线算法

http://acm.hdu.edu.cn/showproblem.php?pid=2586

忽然发现访客量有点多。在贴一个树剖LCA的板子吧。

最近做树形DP和树形结构时，发现LCA这个东西有点家常，而以前也只会离线算法，现在补一下这个知识点，在这里丢两个模板。

在线倍增算法，感觉也不是很难，当你真正的了解了倍增的意思，这个算法真的就不难了。

首先 p[i][j]表示i结点的第2^j个父亲结点，初始化也很简单， p[i][j]=p[p[i][j-1]][j-1]，这个理解了，这个算法理解了一半；

他的父亲结点是排在一条链上，所以这不就是把这个链分成两部分。

我们在寻找LCA时，首先要建图，同时还要保存结点的直接父亲信息，和距离，以及深度等

用DFS就可以了。

然后就是LCA了，这个首先比较x和y的深度，较深的先开始回溯，当同一深度就一起回溯，就完了；网上也有很多博客讲得很好

可以参考一下。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node{
    int v,w;
};
const int N=400010;
vector<node>g[N];
int fa[N],dis[N],dep[N],n,m;
void dfs(int u,int f,int deep)
{
    fa[u]=f,dep[u]=deep;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i].v;
        if(v==f) continue;
        dis[v]=dis[u]+g[u][i].w;
        dfs(v,u,deep+1);
    }
}
int p[N][30];
void init_lca()
{
    for(int j=0;(1<<j)<=n;j++)
        for(int i=1;i<=n;i++)
            p[i][j]=-1;
    for(int i=1;i<=n;i++) p[i][0]=fa[i];
    for(int j=1;(1<<j)<=n;j++)
        for(int i=1;i<=n;i++)
        {
            if(p[i][j-1]!=-1)
                p[i][j]=p[p[i][j-1]][j-1];
        }
}

int LCA(int x,int y)
{
    if(dep[x]<dep[y]) swap(x,y);
    int lg=0;
    while((1<<lg)<=dep[x])lg++;
    lg--;
    for(int i=lg;i>=0;i--){
        if(dep[x]-(1<<i)>=dep[y])
            x=p[x][i];
    }
    if(x==y) return x;
    for(int i=lg;i>=0;i--){
        if(p[x][i]!=-1&&p[x][i]!=p[y][i])
            x=p[x][i],y=p[y][i];
    }
    return fa[x];
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T;cin>>T;
    while(T--){
        cin>>n>>m;
        for(int i=1;i<=n;i++) g[i].clear();
        for(int i=1;i<n;i++){
            int u,v,w;
            cin>>u>>v>>w;
            g[u].push_back(node{v,w});
            g[v].push_back(node{u,w});
        }
        dis[1]=0;
        dfs(1,-1,0);
        init_lca();
        while(m--){
            int u,v;
            cin>>u>>v;
            printf("%d\n",dis[u]+dis[v]-2*dis[LCA(u,v)]);
        }
    }
    return 0;
}

树剖LCA稍微比倍增快一点。

struct edge {
    int v, next;
} ed[maxn << 1];
int head[maxn], cnt, top[maxn], son[maxn], dep[maxn], f[maxn], sz[maxn];
void add_edge(int u, int v) {
    ++cnt;
    ed[cnt].v = v;
    ed[cnt].next = head[u];
    head[u] = cnt;
}
void dfs1(int u, int fa, int d) {
    sz[u] = 1, f[u] = fa, dep[u] = d;
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v == fa) continue;
        dfs1(v, u, d + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[son[u]]) son[u] = v;
    }
}
void dfs2(int u, int t) {
    top[u] = t;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v != f[u] && v != son[u]) dfs2(v, v);
    }
}
int LCA(int x, int y) {
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        x = f[top[x]];
    }
    if (dep[x] > dep[y]) return y;
    return x;
}

 

 

离线算法 是用 tarjan和并查集实现的，总的来说，不难理解，网上很多博客对这个算法写的很好，自己拿这笔跟着博客的思路画一遍就理解了。

///#include <bits/stdc++.h>
#include<stdio.h>
#include<queue>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<vector>
#include<set>
#include<stack>
using namespace std;
const int N=400010;
int n,m,inp[N];
struct node
{
    int u,v,len,next,dis;
}ed[N],ed1[N];

int fa[N],vis[N],dis[N];
int head[N],head1[N],cnt,cnt1;
void init(int n)
{
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    memset(head1,-1,sizeof(head1));
    memset(head,-1,sizeof(head));
    cnt1=cnt=0;
    for(int i=0;i<=n;i++)
    {
        fa[i]=i;
    }
}
void add(int u,int v,int w)
{
    ed[cnt].u=u,ed[cnt].v=v;
    ed[cnt].len=w;
    ed[cnt].next=head[u];
    head[u]=cnt++;
}
void add1(int u,int v)
{
    ed1[cnt1].u=u,ed1[cnt1].v=v;
    ed1[cnt1].next=head1[u];
    head1[u]=cnt1++;
}
int ffind(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=ffind(fa[x]);
}
void unite(int x,int y)
{
    int fx=ffind(x);
    int fy=ffind(y);
    if(fx!=fy)
        fa[fy]=fa[fx];
}
void tarjan(int u)
{
    vis[u]=1;
    for(int i=head[u];i!=-1;i=ed[i].next)
    {
        int v=ed[i].v;
        int w=ed[i].len;
        if(vis[v])
            continue;
        dis[v]=dis[u]+w;
        tarjan(v);
        unite(u,v);
    }
    for(int i=head1[u];i!=-1;i=ed1[i].next)
    {
        int v=ed1[i].v;
        if(vis[v])
        {
            ed1[i].dis=ed1[i^1].dis=ffind(v);
        }
    }
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        int u,v,len;
        init(n);
        for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&u,&v,&len);
            add(u,v,len);
            add(v,u,len);
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            add1(u,v);
            add1(v,u);
        }
        dis[1]=0;
        tarjan(1);
        for(int i=0;i<m;i++)
        {
            int u=ed1[2*i].u,v=ed1[2*i].v,lca=ed1[2*i].dis;
            printf("%d\n",dis[u]+dis[v]-2*dis[lca]);
        }
    }
    return 0;
}
//