LCA(最近公共祖先) 模板

对LCA及算法的介绍：

https://www.cnblogs.com/zhouzhendong/p/7256007.html

https://www.cnblogs.com/scau20110726/archive/2013/05/26/3100812.html

模板：

倍增：

洛谷 P3379

核心思想：二进制，预先处理出树上每个节点的往上走1、 2、 4、……2^n层的点，就可得到所有结果并提高效率。

时间复杂度：预处理O(nlgn)   每次查询(lgn)

#include
#include
#include
using namespace std;

const int maxn=5e5+5;

struct edge
{
    int to,nxt;
}Edge[maxn<<1];

int n,m,root,tot=0;
int head[maxn];
int deep[maxn];
int fa[maxn][30];
int bs[30];

inline void addedge(int u,int v)
{
    Edge[++tot].to=v,Edge[tot].nxt=head[u],head[u]=tot;
    Edge[++tot].to=u,Edge[tot].nxt=head[v],head[v]=tot;
}

void dfs(int cur,int father)
{
    deep[cur]=deep[father]+1;
    fa[cur][0]=father;
    for(int i=1;i<=20;i++)
	fa[cur][i]=fa[fa[cur][i-1]][i-1];
    for(int i=head[cur];i;i=Edge[i].nxt)
        if(Edge[i].to!=father)
            dfs(Edge[i].to,cur);
}
inline int skip(int x,int level)
{
    for(int i=20;i>=0;i--)
    {
        if(bs[i]&level)
            x=fa[x][i];
    }
    return x;
}

inline int LCA(int u,int v)
{
    if(deep[u]=0;i--)
        if(fa[u][i]!=fa[v][i])
            u=fa[u][i],v=fa[v][i];
    return fa[u][0];
}

int main()
{
    for(int i=0;i<=20;i++)
        bs[i]=1<

RMQ：

例题同上

时间复杂度：预处理O(nlgn)     查询O(1) 当查询远大于顶点个数时再考虑此种方法。

#include
#include
#include
#include
using namespace std;

const int maxn=5e5+5;

struct edge
{
    int to,nxt;
}Edge[maxn<<1];

int n,m,root,tot=0,cnt=0;
int head[maxn];
int deep[maxn];
int first[maxn];
int oula[maxn<<1];
int st[maxn<<1][30];
int bs[30];

inline int read()
{
    int tmp=0,f=1;
    char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        tmp=tmp*10+ch-'0',ch=getchar();
    return f*tmp;
}
inline void addedge(int u,int v)
{
    Edge[++tot].to=v,Edge[tot].nxt=head[u],head[u]=tot;
    Edge[++tot].to=u,Edge[tot].nxt=head[v],head[v]=tot;
}

void dfs(int cur,int father)
{
    oula[++cnt]=cur;
    first[cur]=cnt;
    deep[cur]=deep[father]+1;
    for(int i=head[cur];i;i=Edge[i].nxt)
    {
        if(Edge[i].to!=father)
        {
            dfs(Edge[i].to,cur);
            oula[++cnt]=cur;
        }
    }
}

inline void initst()
{
    int tmp1,tmp2;
    for(int i=1;i<=cnt;i++)
        st[i][0]=oula[i];
    for(int j=1;j<=20;j++)
    {
        for(int i=1;i+bs[j]-1<=cnt;i++)
        {
            tmp1=st[i][j-1];
            tmp2=st[i+bs[j-1]][j-1];
            if(deep[tmp1]r)
        swap(l,r);
    int MAX=log2(r-l+1);
    int tmp1=st[l][MAX];
    int tmp2=st[r-bs[MAX]+1][MAX];
    if(deep[tmp1]

树链剖分：

#include
#include
#include
#include
using namespace std;

const int maxn=5e5+5;

struct edge
{
    int to,nxt;
}Edge[maxn<<1];

int n,m,tot=0,cnt=0;
int head[maxn];
int siz[maxn];//子树大小
int son[maxn];//重儿子
int fa[maxn];//父节点
int deep[maxn];//深度
int top[maxn];//所在链链顶
int pos[maxn];//dfs序编号

inline void addedge(int u,int v)
{
    Edge[++cnt].to=v,Edge[cnt].nxt=head[u],head[u]=cnt;
    Edge[++cnt].to=u,Edge[cnt].nxt=head[v],head[v]=cnt;
}

void dfs1(int u,int f)
{
    siz[u]=1,son[u]=0,deep[u]=deep[f]+1,fa[u]=f;
    for(int i=head[u];i;i=Edge[i].nxt)
    {
        if(Edge[i].to!=f)
        {
            dfs1(Edge[i].to,u);
            siz[u]+=siz[Edge[i].to];
            if(siz[Edge[i].to]>siz[son[u]])
                son[u]=Edge[i].to;
        }
    }
}

void dfs2(int u,int f,int k)
{
    pos[u]=++tot;
    top[u]=k;
    if(son[u])
        dfs2(son[u],u,k);
    for(int i=head[u];i;i=Edge[i].nxt)
        if(Edge[i].to!=f&&Edge[i].to!=son[u])
            dfs2(Edge[i].to,u,Edge[i].to);
}

inline int lca(int u,int v)
{
    int f1=top[u],f2=top[v];
    while(f1!=f2)
    {
        if(deep[f1]

Tarjan离线：

待补。