LCA

原创于 2020-08-12 09:33:53 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨了使用LCA算法解决跳跳棋和聚会问题的策略，通过实例展示了如何在树状结构中寻找两点间的最低公共祖先，以优化路径计算。文章提供了详细的代码实现，包括节点添加、深度优先搜索、LCA计算等关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#10137. 「一本通 4.4 练习 4」跳跳棋

太难了，看题解去

#10136. 「一本通 4.4 练习 3」聚会

分别LCA后去最低的

#include <cstdio>
#include <iostream>
using namespace std;
int read() {
    int ret = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') ret = (ret << 1) + (ret << 3) + ch - '0', ch = getchar();
    return ret;
}

int n, m, cnt, id, l1, l2, l3, ans;
const int N = 1e6 + 5;
int lg[N], dep[N], f[N][21], he[N], to[N], nxt[N];

inline void add(int u, int v) {
    to[++cnt] = v;
    nxt[cnt] = he[u];
    he[u] = cnt;
}

void dfs(int fa, int u) {
    dep[u] = !fa ? 0 : dep[fa] + 1;
    f[u][0] = fa;
    for (int i = 1; i <= lg[dep[u]]; i++) f[u][i] = f[f[u][i - 1]][i - 1];
    for (int e = he[u]; e; e = nxt[e]) {
        int v = to[e];
        if (v != fa)
            dfs(u, v);
    }
}

int LCA(int u, int v) {
    if (dep[u] > dep[v])
        swap(u, v);
    ans += dep[v] - dep[u];
    while (dep[u] < dep[v]) v = f[v][lg[dep[v] - dep[u]]];
    for (int i = lg[dep[u]]; i >= 0; i--)
        if (f[u][i] != f[v][i])
            ans += 1 << (i + 1), u = f[u][i], v = f[v][i];
    if (u != v)
        ans += 2, u = f[u][0];
    return u;
}
int main() {
    n = read(), m = read();
    for (int i = 1; i < n; i++) {
        int u = read(), v = read();
        add(u, v), add(v, u);
    }
    lg[0] = -1;
    for (int i = 1; i <= n; i++) lg[i] = lg[i >> 1] + 1;

    dfs(0, 1);
    while (m--) {
        int u1 = read(), u2 = read(), u3 = read();
        ans = 0;
        l1 = LCA(u1, u2);
        l2 = LCA(u1, u3);
        l3 = LCA(u2, u3);
        if (dep[l1] > dep[l2])
            id = l1;
        else
            id = l2;
        if (dep[l3] > dep[id])
            id = l3;
        printf("%d %d\n", id, ans >> 1);
    }
    return 0;
}

或

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 50005
using namespace std;
 
int n,m;
 
struct edge
{
    int next,v;
}edges[maxn*2];
int cnt;
int head[maxn];
 
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void addedge(int u,int v)
{
    edges[cnt].next=head[u];
    edges[cnt].v=v;
    head[u]=cnt++;
}
int dep[maxn];
int f[maxn][21];
void dfs(int u,int fa)
{
    dep[u]=dep[fa]+1;
    for(int i=0;i<=19;i++)
        f[u][i+1]=f[f[u][i]][i];
    for(int i=head[u];i!=-1;i=edges[i].next)
    {
        int v=edges[i].v;
        if(v==fa)
            continue;
        f[v][0]=u;
        dfs(v,u);
    }
}
int lca(int x,int y)
{
if(dep[x]<dep[y])
    swap(x,y);
    for(int i=20;i>=0;i--)
    {
        if(dep[f[x][i]]>=dep[y])
            x=f[x][i];
        if(x==y)
            return x;
    }
    for(int i=20;i>=0;i--)
    {
        if(f[x][i]!=f[y][i])
        {
            x=f[x][i];
            y=f[y][i];
        }
    }
    return f[x][0];
}
int main()
{
scanf("%d%d",&n,&m);
init();
int x,y;
for(int i=1;i<=n-1;i++)
   {
       scanf("%d%d",&x,&y);
       addedge(x,y);
       addedge(y,x);
}
dfs(1,0);
int a,b,c;
for(int i=1;i<=m;i++)
{
    scanf("%d%d%d",&a,&b,&c);
    int fa1=lca(a,b);
 int fa2=lca(b,c);
 int fa3=lca(a,c);
 int len1=dep[a]+dep[b]-2*dep[fa1]+dep[c]+dep[fa1]-2*dep[lca(fa1,c)];
 int len2=dep[a]+dep[c]-2*dep[fa3]+dep[b]+dep[fa3]-2*dep[lca(fa3,b)];
 int len3=dep[b]+dep[c]-2*dep[fa2]+dep[fa2]+dep[a]-2*dep[lca(fa2,a)];
 int len=min(min(len1,len2),len3);
 if(len1==len)
    printf("%d %d\n",fa1,len1);
    else if(len2==len)
    printf("%d %d\n",fa3,len2);
    else if(len3==len)
    printf("%d %d\n",fa2,len3);
}
return 0;
}