算法 -LCA最近公共祖先求最短路算法

$$LCA最近公共祖先求最短路算法$$

自己研究的扯淡算法，不知道有没有重复的

[算法定义及适用范围]
LCA(最近公共祖先)是一种树上的算法，求任意两点A，B的最近公共祖先。一幅n个顶点，n-1条边的图就认可以认为这幅图是一棵树。
如下图是一幅n个顶点，n-1条边的图，即一棵树。随机取出两个点X，Y，找到他们的最近公共祖先，即点1。在寻找最近公共祖先的同时，ans记录走过的路径长度。在找到最近公共祖先的时候，找到最短路，算法结束。

---

[模拟过程]
如上图，寻找X，Y的最短路，即寻找他们的最近公共祖先
Step (1):X往father[x]走一步，达到和Y同一层 ans+=1
此时 X在点4,Y在点6,ans=1
Step (2):X和Y同时向各自的父亲节点father[X],father[Y]走 ans+=2,ans+=5
此时 X在点2，Y在点3，ans=8
Step(3): X和Y同时向各自的父亲节点father[X],father[Y]走 ans+=3,ans+=6
此时 X在点1，Y在点1，ans=17 算法结束

---

[算法实现]
N个点，M条边，求最短路

int lca(int a,int b){
    int ans=0;
    if (deep[a]>deep[b]) swap(a,b);
    while (deep[b]>deep[a]) ans+=map[b][set[b]],b=set[b];
    while (a!=b) ans+=map[b][set[b]]+map[a][set[a]],a=set[a],b=set[b];
    return ans;
}

其中需要预处理的过程

• 构建最小生成树

 int find(int a){ 
    if(set[a] != a) set[a]=find(set[a]);
    return set[a];
}

bool built(int x,int y){ 
    int s1=find(x), s2=find(set[y]);
    if(s1!=s2) {set[s2]=s1;  return true;}
    return false;
}

bool cmp(First x,First y){return x.w<y.w;} 

void kruskal(){ 
    for(int i=1;i<=n;i++) set[i]=i;
    sort(init+1,init+m+1,cmp);
    int num=0;
    for(int i=1;i<=m;i++)
      if(built(init[i].u,init[i].v)) { 
        map[init[i].u][init[i].v]=map[init[i].v][init[i].u]=init[i].w;
        num++;
        if(num==n-1) break;
    }
}

• 记录节点深度

  void dfs(){
  for(int i=1;i<=n;i++)
      for(int j=i+1;j<=n;j++)
          if(map[i][j]!=0x3f3f3f3f && !vis[j])
              deep[j]=deep[i]+1,vis[j]=true;
  }

  [完整代码]

#include <iostream>
#include <iomanip>
#include <cstdio>
using namespace std;

int n,m;
struct First{int u,v,w;}init[2000];
int map[2000][2000],set[2000],deep[2000];
bool vis[2000];

int find(int a){ 
    if(set[a] != a) set[a]=find(set[a]);
    return set[a];
}

bool built(int x,int y){ 
    int s1=find(x), s2=find(set[y]);
    if(s1!=s2) {set[s2]=s1;  return true;}
    return false;
}

bool cmp(First x,First y){return x.w<y.w;} 

void kruskal(){ 
    for(int i=1;i<=n;i++) set[i]=i;
    sort(init+1,init+m+1,cmp);
    int num=0;
    for(int i=1;i<=m;i++)
      if(built(init[i].u,init[i].v)) { 
        map[init[i].u][init[i].v]=map[init[i].v][init[i].u]=init[i].w;
        num++;
        if(num==n-1) break;
    }
}

void dfs(){
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
            if(map[i][j]!=0x3f3f3f3f && !vis[j])
                deep[j]=deep[i]+1,vis[j]=true;
}

int lca(int a,int b){
    int ans=0;
    if (deep[a]>deep[b]) swap(a,b);
    while (deep[b]>deep[a]) ans+=map[b][set[b]],b=set[b];
    while (a!=b) ans+=map[b][set[b]]+map[a][set[a]],a=set[a],b=set[b];
    return ans;
}

int main()
{
    freopen("lca.in","r",stdin);
    freopen("lca.out","w",stdout);
    memset(map,0x3f,sizeof(map));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) scanf("%d%d%d",&init[i].u,&init[i].v,&init[i].w);
    kruskal(); deep[1]=1; dfs(); int A,B;
    scanf("%d%d",&A,&B);
    printf("%d",lca(A,B));
    return 0;
}

[可拓展的范围]
使用邻接表存储，使用倍增优化等