菜鸟系列——最近公共祖先（LCA）

最新推荐文章于 2023-02-23 20:14:53 发布

kopyh

最新推荐文章于 2023-02-23 20:14:53 发布

阅读量500

点赞数

分类专栏：菜鸟系列图论

本文链接：https://blog.csdn.net/kopyh/article/details/50503292

版权

菜鸟系列同时被 2 个专栏收录

23 篇文章 2 订阅

订阅专栏

图论

18 篇文章 0 订阅

订阅专栏

菜鸟就要老老实实重新学起：

最近公共祖先（LCA）

求树上亮点的最近公共祖先，就是求包含这两个点的最小的子树的根节点。

离线算法（Tarjan）：

就是预先储存所有询问，然后深搜便利所有点，后序遍历找到每个询问中的点，对于每个询都是在两个点都找到的那一刻得到最近公共祖先，后序遍历中不断把点加入并查集中，已加入的最上面的点就是当前的根节点。

模版：

const int MAXN = 101001;
const int MAXM = 101001;
const int MAXQ = 101001;
struct Tree{
    int head[MAXN];//前向星存图
    int next[MAXM];
    int to[MAXM];
    int val[MAXM];//权值
    int pos;
    Tree()
    {
        clear();
    }
    void clear()
    {
        memset(head,-1,sizeof(head));
        memset(val,0,sizeof(val));
        pos = 0;
    }
    void add(int u,int v,int w)
    {
        val[pos] = w;
        to[pos] = v;
        next[pos] = head[u];
        head[u] = pos++;
    }
}tree;
bool v[MAXN];
int in[MAXN];//入度
int dist[MAXN];//与根节点距离
int father[MAXN];//并查集处理
int n,m,q;
vector<int>query[MAXQ],num[MAXQ];
int ans[MAXQ];

void Init()
{
    memset(v,0,sizeof(v));
    memset(in,0,sizeof(in));
    memset(ans,0,sizeof(ans));
    for(int i=0;i<MAXQ;i++)
    {
        query[i].clear();
        num[i].clear();
    }
    tree.clear();
}
int Find(int x)
{
    if(father[x] != x)
        father[x] = Find(father[x]);
    return father[x];
}
void getDist(int u)//计算节点到根距离
{
    for(int i = tree.head[u];i!=-1;i=tree.next[i])
    {
        dist[tree.to[i]] = dist[u] + tree.val[i];
        getDist(tree.to[i]);
    }
}
void Tarjan(int u)
{
    father[u] = u;//当访问到一个节点的时候，先将其自己形成一个集合
    v[u] = true;//标记访问
    for(int i = tree.head[u];i!=-1;i=tree.next[i])
    {
        Tarjan(tree.to[i]);//递归处理
        father[tree.to[i]] = u;//处理结束后，将子节点集合加到父节点
    }
    for(int i = 0; i < query[u].size(); i++)//便利询问
    {
        if(v[query[u][i]])
        {
            ans[num[u][i]] =Find(query[u][i]);
        }
    }
}
int main()
{
    int x,y,t;
    Init();
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&t);
        tree.add(x,y,t);
        in[y]++;
    }
    scanf("%d",&q);
    for(int i=0;i<q;i++)
    {
        scanf("%d%d",&x,&y);
        query[x].push_back(y);
        query[y].push_back(x);
        num[x].push_back(i);
        num[y].push_back(i);
    }
    for(int i=1;i<=n;i++)
        if(in[i] == 0)
        {
            dist[i]=0;
            getDist(i);
            Tarjan(i);
            break;
        }
    //ans中得到的是最近公共祖先的节点，最近距离就是dist[x]+dist[y]-2*dist[ans[i]];
    for(int i=0;i<q;i++)
        printf("%d\n",ans[i]);
    return 0;
}

eg:

POJ1330 Nearest Common Ancestors

http://blog.csdn.net/kopyh/article/details/50503461

在线算法（ST-RMQ）

利用rmq算法进行在线判断，提前对树进行预处理，得到一个树的深搜序列，长为2*n-1，并且储存每个位置的树节点的编号、深度和与根的距离。并储存每个节点第一次出现在深搜序列中的位置。然后对于对点，他们的最近公共祖先的序号一定就在他们在深搜序列的出现位置之间。对于这一段序列rmq求深度最小的点就是了。

模版：

#define N 40010
#define M 25
int n,m;
int flag,sum,ave,ans,res,num;
bool vis[N];
int dp[2*N][M], head[N];
struct node
{
    int u,v,w,next;
}e[2*N];
inline void add(int u ,int v ,int w )
{
    e[num].u = u; e[num].v = v; e[num].w = w;
    e[num].next = head[u]; head[u] = num++;
    u = u^v; v = u^v; u = u^v;
    e[num].u = u; e[num].v = v; e[num].w = w;
    e[num].next = head[u]; head[u] = num++;
}
int ver[2*N],R[2*N],first[N],dir[N];
//ver:节点编号 R：深度 first：点编号位置 dir：距离
void Init()
{
    num = 0;  sum = 0; dir[1] = 0;
    memset(head,-1,sizeof(head));
    memset(vis,false,sizeof(vis));
}
void dfs(int u ,int dep)
{
    vis[u] = true; ver[++sum] = u; first[u] = sum; R[sum] = dep;
    for(int k=head[u]; k!=-1; k=e[k].next)
        if( !vis[e[k].v] )
        {
            int v = e[k].v , w = e[k].w;
            dir[v] = dir[u] + w;
            dfs(v,dep+1);
            ver[++sum] = u; R[sum] = dep;
        }
}
void ST(int n)
{
    for(int i=1;i<=n;i++)
        dp[i][0] = i;
    for(int j=1;(1<<j)<=n;j++)
    {
        for(int i=1;i+(1<<j)-1<=n;i++)
        {
            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = R[a]<R[b]?a:b;
        }
    }
}
//中间部分是交叉的。
int RMQ(int l,int r)
{
    int k=0;
    while((1<<(k+1))<=r-l+1)
        k++;
    int a = dp[l][k], b = dp[r-(1<<k)+1][k]; //保存的是编号
    return R[a]<R[b]?a:b;
}

int LCA(int u ,int v)
{
    int x = first[u] , y = first[v];
    if(x > y) swap(x,y);
    int res = RMQ(x,y);
    return ver[res];
}

int main()
{
    int n,q,u,v,w,lca;
    Init();
    scanf("%d%d",&n,&q);
    for(int i=1; i<n; i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    dfs(1,1);
    ST(2*n-1);
    while(q--)
    {
        scanf("%d%d",&u,&v);
        lca = LCA(u,v);
        printf("%d\n",dir[u] + dir[v] - 2*dir[lca]);
    }
    return 0;
}