hdu 4547 CD操作 LCA倍增算法

最新推荐文章于 2022-09-02 20:56:37 发布

原创最新推荐文章于 2022-09-02 20:56:37 发布 · 189 阅读

0 ·

CC 4.0 BY-SA版权

LCA 专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了CD操作在图论中的应用，特别是在解决树形结构中两点间距离问题时的方法。通过介绍如何利用LCA（最近公共祖先）算法优化路径查找，实现了从任意一点快速到达另一点的目标。文章详细解析了算法实现步骤，包括节点深度计算、LCA查找技巧及最终距离计算策略。

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

hdu 4547 CD操作

在CD操作中，向下操作：x点能 1 步到达所有以 x 点为根节点的子树中的所有节点

向上操作：只能一步一步向上查找父节点（一次只能走一个点）

思路：

找出两点的最近公共祖先，判断要变成的点是否为最近公共祖先，不是就加 1 ，否则直接输出

#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<sstream>
#include<cstring>
#include<bitset>
#include<cstdio>
#include<string>
#include<deque>
#include<stack>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#define mod 1000000007
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
struct node
{
    int to;
    int next;
}e[2*maxn];
int n,m,cnt,N;
int fa[maxn][20]; //表示节点i往上跳2^j次后的节点  注意j的取值范围
int head[maxn];
int d[maxn];  //当前节点所在的深度
int pre[maxn];  //判断根节点
int tot,root;
map<string,int> ma;
void add(int u,int v)
{
    cnt++;
    e[cnt].to = v;
    e[cnt].next = head[u];
    head[u] = cnt;
}
void init()  //初始化
{
    cnt = tot = 0;
    N = (int)(log(1.0*n)/log(2))+1;

    memset(head,0,sizeof(head));
    memset(pre,0,sizeof(pre));
    memset(fa,0,sizeof(fa));
    memset(d,0,sizeof(d));

    ma.erase(ma.begin(),ma.end());
}
void dfs(int u,int f)
{
    for(int i=1;i<=N;i++)
        fa[u][i] = fa[fa[u][i-1]][i-1];  //i的第2^j祖先就是i的第2^(j-1)祖先的第2^(j-1)祖先

    for(int i=head[u]; i ;i=e[i].next)   //每一个与u相连的节点i
    {
        int v = e[i].to;
        if(v==f)
            continue;
        d[v] = d[u]+1;    //更新深度
        fa[v][0] = u;
        dfs(v,u);
    }
}//深搜出各点的深度，存在d中

int lca(int u,int v)
{
    if(d[u]<d[v])
    swap(u,v);   //保证深度大的点为u，方便操作
    int dc=d[u]-d[v];   //计算深度差
    int i;
    for(i=0;i<=N;i++)  //值得注意的是，这里需要从零枚举
    {                    //此循环用于提到深度相同
        if((1<<i)& dc)
            u=fa[u][i];
    }
    if(u==v)   //如果深度一样时，两个点相同，直接返回
        return u;
    for(i=N;i>=0;i--)  //如果从小到大的话就有可能无法提到正确位置
    {
        if(fa[u][i]!=fa[v][i])//跳2^j步，如果不一样，就跳，否则不跳 如果相等有可能都为0 即超过根节点
        {//在同一高度了,他们一起向上跳,跳他们不相同节点，当全都跳完之后fa[u][0]就是lca
            u=fa[u][i];
            v=fa[v][i];
        }
    }
    u=fa[u][0]; //上述过程做完，两点都在LCA下一层，所以走一步即可
    return u;
}
int main()
{
    std::ios::sync_with_stdio(false);
    int t;
    string a,b;
    char s[10];
    cin>>t;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=1;i<n;i++)
        {
            cin>>a>>b;
            if(!ma[a])
                ma[a] = ++tot;
            if(!ma[b])
                ma[b] = ++tot;
            int u = ma[b];
            int v = ma[a];
            pre[v] = u;
            add(u,v);
            if(pre[u]==0)
                root = u;
        }
        d[root] = 1;
        dfs(root,0);
        for(int i=0;i<m;i++)
        {
            cin>>a>>b;
            int x = ma[a];
            int y = ma[b];
            int z = lca(x,y);
            int ans = d[x]-d[z];  
            if(y!=z)  //判断 y 是否就是最近公共祖先节点
                ans++;  // 以某 z 为根节点的子树，从 z 节点能一步到达所有子节点
            cout<<ans<<endl;
        }
    }
    return 0;
}