lca倍增算法学习记录

找最近公共父节点这问题很容易想到让两节点一起往上走最后相遇,但这样的dfs显然很慢,于是就需要倍增。就是用二进制的思维,以1,2,4,8等2的阶层步长接近答案,比一步一步向上要快很多。
所以要dfs出来点的2^k的父亲节点与该节点的深度。
找lca时先将下面的点升到与另一点同一深度,再用往上倍增找lca。
有两种大同小异的方法:一种是以上一步2倍长的步伐向上试,不行再缩减,找到一个离lca能达到的最近点。另一种是先求出最大深度是2的几次方,再以当前最大步伐向上走。具体看下面代码,喜欢哪种打哪种。。。
简单一题hdu2586
大意是求两节点距离,只用在dfs时求从根到节点的距离,用L=dis[i]+dis[j]-2*dis[lca(i+j)]求出。
以下代码:

#include<stdio.h>
#include<algorithm>
#include<string.h>

using namespace std;

const int maxn=40005;

int tot;
int a[maxn],b[maxn*2],c[maxn*2],w[maxn*2],deep[maxn],dis[maxn],fa[maxn][16];   //注意边要两倍空间 
bool bo[maxn];

void setin(int x,int y,int z)           //邻接表储存图 
{
    b[++tot]=a[x];
    a[x]=tot;
    c[tot]=y;
    w[tot]=z;
}

void dfs(int x)                         //预处理 
{
    int p,son;
    p=a[x];
    while(p)
    {        
        son=c[p];
        if(!bo[son])
        {
            bo[son]=true;                 //避免走回去 
            fa[son][0]=x;
            deep[son]=deep[x]+1;
            dis[son]=dis[x]+w[p];
            int ii=0,po=x;
            while(fa[po][ii]!=0)
            {
                fa[son][ii+1]=fa[po][ii];  
                po=fa[po][ii++];          //关键!父节点相当于每次*2,来更新这个子节点的2^k父节点,自己模拟就明白了 
            }
            dfs(son);
        }
        p=b[p];
    }
}

int lca(int x,int y)
{

    if(x==y) return x;
    if(deep[x]<deep[y]) swap(x,y);
    int m=deep[x]-deep[y],ii=0;
    while(m)                              //m表示为二进制,以2,4,8等步伐向上 
    {
        if(m&1==1) x=fa[x][ii];
        m>>=1;
        ii++;
    }
    ii=0;
    while(x!=y)
      if(fa[x][ii]!=fa[y][ii]||((fa[x][ii]==fa[y][ii])&&(ii==0)))  //条件很关键,仅有一步时要走才能退出循环 
      {
          x=fa[x][ii];
          y=fa[y][ii];
          ii++;
      }
      else ii--;
    return x;  
}
int main()
{
    int t,n,q,x,y,z;
    scanf("%d",&t);
    for(int i=0;i<t;i++)
    {
        tot=0;
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        memset(w,0,sizeof(w));
        memset(deep,0,sizeof(deep));
        memset(dis,0,sizeof(dis));
        memset(fa,0,sizeof(fa));
        memset(bo,0,sizeof(bo));        
        scanf("%d%d",&n,&q);
        for(int j=0;j<n-1;j++)
        {
            scanf("%d%d%d",&x,&y,&z);
            setin(x,y,z);
            setin(y,x,z);
        }
        deep[1]=1;
        dis[1]=0;
        bo[1]=true;
        dfs(1);
        for(int j=0;j<q;j++)
        {
            scanf("%d%d",&x,&y);
            printf("%d\n",dis[x]+dis[y]-2*dis[lca(x,y)]);
        }
    }
}

另一种lca求法:

int lca(int x,int y)
{
    int i,j;
    if(deep[x]<deep[y])swap(x,y);
    for(i=0;(1<<i)<=deep[x];i++);   //求深度是2的几次方,给下面循环找上界 
    i--;
    for(j=i;j>=0;j--)
        if(deep[x]-(1<<j)>=deep[y])
            x=fa[x][j];             //另一种将x提到与y同高度的写法 
    if(x==y)return x;
    for(j=i;j>=0;j--)
    {
        if(fa[x][j]!=fa[y][j])
        {
            x=fa[x][j];
            y=fa[y][j];
        }
    }
    return fa[x][0];   //注意是把2^k拆成1和其他2的次方,所以返回父节点 
}

ps:因为并不会vector释放内存,就写了一大串memset,求大神指教如何简化。

LCA+路径压缩的方式可以用于求解树上的桥,具体实现步骤如下: 1. 对于树上每个节点,记录其在树中的深度(或者高度)以及其父亲节点。 2. 对于每个节点,记录其在树上的最小深度(或最小高度)以及其所在子树中深度最小的节点。 3. 对于每条边(u, v),设u的深度小于v的深度(或者高度),则如果v的子树中没有深度小于u的节点,则(u, v)是桥。 具体的实现过程如下: 首先,我们需要对树进行预处理,求出每个节点的深度以及其父亲节点。可以使用深度优先搜索(DFS)或广度优先搜索(BFS)来实现。在这里我们使用DFS来实现: ```c++ vector<int> adj[MAX_N]; // 树的邻接表 int n; // 树的节点数 int dep[MAX_N], fa[MAX_N]; // dep[i]表示节点i的深度,fa[i]表示节点i的父亲节点 void dfs(int u, int f, int d) { dep[u] = d; fa[u] = f; for (int v : adj[u]) { if (v != f) { dfs(v, u, d + 1); } } } ``` 接下来,我们需要计算每个节点所在子树中深度最小的节点。我们可以使用LCA(最近公共祖先)的方法来实现。具体来说,我们可以使用倍增算法来预处理出每个节点的2^k级祖先,并且在查询LCA时使用路径压缩的方式优化时间复杂度。这里我们不展开讲解LCA倍增算法的细节,如果你对此感兴趣,可以参考其他资料进行学习。 ```c++ const int MAX_LOG_N = 20; // log2(n)的上取整 int anc[MAX_N][MAX_LOG_N]; // anc[i][j]表示节点i的2^j级祖先 int mn[MAX_N]; // mn[i]表示节点i所在子树中深度最小的节点 void precompute() { // 预处理anc数组 for (int j = 1; j < MAX_LOG_N; j++) { for (int i = 1; i <= n; i++) { if (anc[i][j - 1] != -1) { anc[i][j] = anc[anc[i][j - 1]][j - 1]; } } } // 计算mn数组 for (int i = 1; i <= n; i++) { mn[i] = i; for (int j = 0; (1 << j) <= dep[i]; j++) { if ((dep[i] & (1 << j)) != 0) { mn[i] = min(mn[i], mn[anc[i][j]]); i = anc[i][j]; } } } } ``` 最后,我们可以使用LCA+路径压缩的方式来判断每条边是否为桥。具体来说,对于每条边(u, v),我们需要判断v的子树中是否存在深度小于u的节点。如果存在,则(u, v)不是桥,否则(u, v)是桥。 ```c++ bool is_bridge(int u, int v) { if (dep[u] > dep[v]) swap(u, v); if (mn[v] != u) return true; // 子树中存在深度小于u的节点 return false; // 子树中不存在深度小于u的节点 } ``` 完整代码如下:
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值