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

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

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

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

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

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

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

用DFS就可以了。

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

可以参考一下。

#include
using namespace std;
typedef long long ll;
struct node{
    int v,w;
};
const int N=400010;
vectorg[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=0;i--){
        if(dep[x]-(1<=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>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;
}

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

///#include 
#include
#include
#include
#include
#include
#include
#include
#include
#include
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