LCA

最新推荐文章于 2022-07-15 22:16:27 发布

流沙-岁月

最新推荐文章于 2022-07-15 22:16:27 发布

阅读量368

点赞数

分类专栏： LCA

本文链接：https://blog.csdn.net/u013475704/article/details/48897393

版权

LCA 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.概述

LCA（Least Common Ancestor），即最近公共祖先，指这样一个问题：在一棵树上，求出u和v两个节点的最近公共祖先，而最近公共祖先指u和v所有公共祖先中，深度最深的那个。

例如，上图中，4和5的最近公共祖先就是2.

2.LCA算法

朴素解法

求u和v的最近公共祖先，只需沿着u和v向上搜索，当搜索到的某一节点重叠时，那个节点就是所求的最近公共祖先。设u的深度为deep[u]，v的深度为deep[v]，那么让更深的那个先向上走| deep[u]-deep[v] | 步，接着再一起向上走。时间复杂度是o(max(deep[u],deep[v]))。

离线算法（Tarjan算法）

Tarjan算法基本上是DFS和并查集的利用，由于是离线算法，所以是先将所有查询存储起来，重新安排查询顺序以处理每个查询。

算法思想是：当搜索到一个节点时，将该节点改为已标记，接着依次搜索该节点的所有子树。每当搜索完一个子树时，也必定处理完了有关该子树的所有查询（即查询中两个节点都在该子树或一个节点在该子树，另一个节点在前面已经搜索过了的子树中，指这样的查询），而且将搜索完的子树包含的节点集合并入当前节点，并且以当前节点为祖先节点（利用并查集完成此操作），接着再去搜索下一课子树。当所有子树都搜索完后，处理与当前节点有关的查询。若当前节点为u，则对查询中存在的(u,x)，判断x是否已经标记过了，若已经标记，则(u,x)的最近公共祖先就是x节点的祖先。

伪代码如下：

Tarjan（u）

{

vis[u]=true;

make_set(u);

for u 的每一个子节点x

Tarjan（x）

将x子树的节点集合并入u，并以u为祖先

for 每一个（u，x）

if (x 已标记) （u，x）的祖先为 x在并查集中的祖先

}

hdu 2586

#include <cstdio>
#include <stack>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <list>
#include <functional>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <string>
#include <map>
#include <iomanip>
#include <cmath>
#define LL long long
#define ULL unsigned long long
#define SZ(x) (int)x.size()
#define MP(a, b) make_pair(a, b)
#define MS(arr, num) memset(arr, num, sizeof(arr))
#define PB push_back
#define F first
#define S second
#define ROP freopen("input.txt", "r", stdin);
#define MID(a, b) (a + ((b - a) >> 1))
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define lrt rt << 1
#define rrt rt << 1|1
#define root 1,n,1
#define BitCount(x) __builtin_popcount(x)
#define BitCountll(x) __builtin_popcountll(x)
#define LeftPos(x) 32 - __builtin_clz(x) - 1
#define LeftPosll(x) 64 - __builtin_clzll(x) - 1
const double PI = acos(-1.0);
const int INF = 1e7;
using namespace std;
const double eps = 1e-5;
const int MAXN = 300 + 10;
const int MOD = 1000007;
const int N=400100;
const int MAX=log2(N*1.0);
typedef pair<int, int> pii;
typedef pair<int, string> pis;
int n,m;
struct node
{
    int to,w,next;
};
node e[N],q[N];
int cnt,cnt1, head[N],first[N],res[N],f[N],dis[N];
bool vis[N];
void init()
{
    cnt=0;
    cnt1=0;
    MS(head,-1);
    MS(first,-1);
    MS(vis,false);
    MS(dis,0);
}
void addedge(int u,int v,int w)
{
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
void addquery(int u,int v,int w)
{
    q[cnt1].to=v;
    q[cnt1].w=w;
    q[cnt1].next=first[u];
    first[u]=cnt1++;
}
int find(int x)
{
    return x==f[x]?x:f[x]=find(f[x]);
}
void lca(int u)
{
    int i,j;
    vis[u]=true;
    f[u]=u;
    for (i=head[u];i!=-1;i=e[i].next) if (!vis[e[i].to]) {
        dis[e[i].to]=dis[u]+e[i].w;
        lca(e[i].to);
        f[find(e[i].to)]=f[u];
    }
    for (i=first[u];i!=-1;i=q[i].next) if (vis[q[i].to]) {
        res[q[i].w]=dis[u]+dis[q[i].to]-2*dis[find(q[i].to)];
        //printf("(%d,%d)=%d\n",u,q[i].to,find(q[i].to));
    }
}
int main()
{
    int i,j,T;
    cin>>T;
    while(T--)
    {
        int a,b,c;
        init();
        scanf("%d%d",&n,&m);
        for (i=1;i<n;i++) {
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
            addedge(b,a,c);
        }
        for (i=0;i<m;i++) {
            scanf("%d%d",&a,&b);
            addquery(a,b,i);
            addquery(b,a,i);
        }
        dis[1]=0;
        lca(1);
        for (i=0;i<m;i++) {
            printf("%d\n",res[i]);
        }
    }
}

/*
5
5 5
1 2 2
2 3 3
3 4 4
4 5 5
2 3
3 4
4 5
1 5
1 1


*/