【董晓算法】竞赛常用知识之图论3（最近公共祖先）

前言：

本系列是学习了董晓老师所讲的知识点做的笔记

董晓算法的个人空间-董晓算法个人主页-哔哩哔哩视频 (bilibili.com)

 动态规划系列（还没学完）

【董晓算法】动态规划之线性DP问题-CSDN博客

【董晓算法】动态规划之背包DP问题（2024.5.11）-CSDN博客

【董晓算法】动态规划之背包DP与树形DP-CSDN博客

字符串系列（）

【董晓算法】竞赛常用知识之字符串1-CSDN博客

【董晓算法】竞赛常用知识之字符串2-CSDN博客

数据结构系列（未学完）

【董晓算法】竞赛常用知识点之数据结构1-CSDN博客

搜索系列

[董晓算法]搜索相关题目及模板-CSDN博客

图论系列 

【董晓算法】算法知识之图论1（拓扑排序，多种最短路算法）-CSDN博客

【董晓算法】竞赛常用知识之图论2（最小环，最小生成树）-CSDN博客

最近公共祖先

倍增算法

倍增算法是最经典的求 LCA 算法
dep]存u点的深度。fa[u][i] 存从 u 点向上跳 2 层的祖先结点。

步骤：

1.dfs 一遍，创建 ST 表（倍增递推，fa[u][i]=fa[fa[u][i-1]][i-1])

2.利用 ST 表求 LCA

const int N=5e5+10;
int n,m,s;
vector<int> e[N];
int dep[N],fa[N][22];

void dfs(int u,int father){ //树增dep,fa
  dep[u]=dep[father]+1; 
  fa[u][0]=father;
  for(int i=1; i<=20; i++) 
    fa[u][i]=fa[fa[u][i-1]][i-1]; 
  for(int v : e[u])
    if(v!=father) dfs(v,u);
}
int lca(int u,int v){ //树增lca
  if(dep[u]<dep[v]) swap(u,v);
  //先跳到同一层
  for(int i=20; i>=0; i--)
     if(dep[fa[u][i]]>=dep[y]) 
           u=fa[u][i];
  if(u==v) return v;
  for(int i=20; i>=0; i--)
    if(fa[u][i]!=fa[v][i]) 
        x=fa[u][i],y=fa[v][i];
  return fa[u][0];
}

Tarjan 算法

Tarjan(塔扬)算法是一种离线算法，巧妙利用并查集维护祖先结点

1.从根开始深搜遍历，入u时 打标记

2.枚举u的儿子v、遍历完v的子树，回u时 把v指向 u。

3.遍历完u的儿子们，离u时 枚举以 u为起点的查询，若终点 v被搜过则查找 v的根，即 uv 的 LCA，答案记入 ans0。

4.递归遍历完整颗树，得到全部查询答案。

 i是第i个查询 

vector<int> e[N];
vector<pair<int,int>>query[N];
int fa[N],vis[N],ans[M]; 
int find(int u){
  if(u==fa[u]) return u;
  return fa[u]=find(fa[u]);
}
void tarjan(int u){
  vis[u]=true;//标记u已访问
  for(auto y : e[u]){
    if(!vis[y]){
      tarjan(y);
      fa[y]=u;//回到u时v指向u    
    }        
  }
  //离开u时找LCA
  for(auto q : query[u]){
    int y=q.first,i=q.second;
    if(vis[y])ans[i]=find(y);
  }
}

树链剖分

概念

1. 重儿子：父结点的所有儿子中子树结点数目最多的结点
2. 轻儿子：父结点中除重儿子以外的儿子
3. 重边:父结点和重儿子连成的边
4. 轻边:父结点和轻儿子连成的边
5. 重链：由多条重边连接而成的路径

1.整棵树会被剖分成若干条重链。

2.轻儿子一定是每条重链的顶点。

3.任意一条路径被切分成不超过 logn 条链

流程

1.第一遍 dfs，搞出 fa.dep.son 数组
2.第二遍 dfs，搞出 top 数组
3.让两个游标沿着各自的重链向上跳，跳到同一条重链上时，深度较小的那个游标所指向的点，就是 LCA

vector<int> e[N];
int fa[N],son[N],dep[N],siz[N];
int top[N];
void dfs1(int u,int father){ //搞fa,dep,son son存u的重儿子
  fa[u]=father;dep[u]=dep[father]+1;siz[u]=1;
  for(int v:e[u]){
    if(v==father) continue;
    dfs1(v,u);
    siz[u]+=siz[v];
    if(siz[son[u]]<siz[v])son[u]=v;
  }
}
void dfs2(int u,int t){ //搞top
  top[u]=t;  //记录链头
  if(!son[u]) return; //无重儿子
  dfs2(son[u],t);     //搜重儿子
  for(int v:e[u]){
    if(v==fa[u]||v==son[u])continue;
    dfs2(v,v); //搜轻儿子
  }
}
int lca(int u,int v){
  while(top[u]!=top[v]){
    if(dep[top[u]]<dep[top[v]])swap(u,v);
    u=fa[top[u]];
  }
  return dep[u]<dep[v]?u:v;
}