【lca】lca转rmq解法

LCA（a，b）转RMQ就是把从节点a到节点b的这条路径记下来，（用dfs访问变成一维数组，我们称为欧拉序列），询问lca(a,b),就是dfs第一次出现a,b位置 frist[a],frist[b],然后求欧拉序列上面 [ frist[a],frist[b] ] 区间去找深度值最小的那个节点，这个节点的编号对应的节点就是所求的LCA。

至于为什么说深度最小的这个节点为所求是因为深度最小这个节点当然在这条路径的最上面，故为所求

一、最近公共祖先(Least Common Ancestors)
对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。
这里给出一个LCA的例子：
例一
对于T=<V,E>
V={1,2,3,4,5}
E={(1,2),(1,3),(3,4),(3,5)}
则有：
LCA(T,5,2)=1
LCA(T,3,4)=3
LCA(T,4,5)=3

RMQ问题与LCA问题的关系紧密，可以相互转换，相应的求解算法也有异曲同工之妙。下面给出LCA问题向RMQ问题的转化方法。

 

 比如求lca(5，3)  找到frist(5)=3,frist(3)=8.故在欧拉序列F中序号在[3,8]的深度最小点为lca(5,3),就是求B序列在[3,8]的最小值用rmq的st算法求出最小值对应的脚标index ,   F(index)为lca(5,3).

代码模版如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>

using namespace std;

#define MAXN 10005
#define MAXM 105
#define inf 0x7ffffff
int n;
struct Edge
{
    int v,next;
}edge[MAXN];
int head[MAXN];
int e;

void clear()//初始化
{
    memset(head,-1,sizeof(head));
    e=0;
}
void addEdge(int u,int v)//加边
{
    edge[e].v=v;
    edge[e].next=head[u];head[u]=e++;
}
int first[MAXN];//结点在搜索顺序数组中最先出现的位置（下标）
int occur[MAXN<<1];//结点在出现的顺序数组重复的也要记录
int depth[MAXN<<1];//结点在搜索树中的深度，与occur相对应
int dp_min[MAXN<<1][20];//dp_min[i][j] 表示从第i个位置开始的2^j个元素中的最小值的下标
int m=0;//不断记录出现的下标

void dfs(int u,int deep)
{
    occur[++m]=u;//进入该点时进行记录
    depth[m]=deep;
    if(!first[u])
        first[u]=m;
    for(int i=head[u];i+1;i=edge[i].next)
    {
        dfs(edge[i].v,deep+1);
        occur[++m]=u;//访问子树返回也要标记
        depth[m]=deep;
    }
}
void init()
{
    clear();
    m=0;
    memset(first,0,sizeof(first));
    bool in[MAXN];//记录结点有无入度
    memset(in,false,sizeof(in));
    int u=0,v=0;
    scanf("%d",&n);
    for(int i=1;i<n;i++)//注意此题只有n-1条边
    {
        scanf("%d%d",&u,&v);
        addEdge(u,v);//u->v单向
        in[v]=true;
    }
    for(int i=1;i<=n;i++)//从根开始dfs
    {
        if(!in[i])
        {
            dfs(i,0);
            break;
        }
    }
}

void RMQ_init(int num)
{
    for(int i=1;i<=num;i++)
        dp_min[i][0]=i;//注意dp_min存的不是最小值，而是最小值的下标
    for(int j=1;j<20;j++)
        for(int i=1;i<=num;i++)
        {
            if(i+(1<<j)-1 <= num)
            {
                dp_min[i][j] = depth[dp_min[i][j-1]] < depth[dp_min[i+(1<<(j-1))][j-1]] ? dp_min[i][j-1] : dp_min[i+(1<<(j-1))][j-1];
            }
        }
}

int RMQ_min(int a,int b)
{
    int l=first[a],r=first[b];//得到区间左右端点
    if(l>r)
    {
        int t=l;
        l=r;
        r=t;
    }
    int k=(int)(log(double(r-l+1))/log(2.0));
    int min_id=depth[dp_min[l][k]]<depth[dp_min[r-(1<<k)+1][k]]?dp_min[l][k]:dp_min[r-(1<<k)+1][k];//最小值下标
    return occur[min_id];//取得当前下标表示的结点
}

int main()
{
    int t;
    int a,b;
    scanf("%d",&t);
    while(t--)
    {
        init();
        RMQ_init(m);
        scanf("%d%d",&a,&b);
        printf("%d\n",RMQ_min(a,b));
    }
    return 0;
}

 

总结:

RMQ是给定一列数，动态询问［i,j］区间内的最小（或最大值）。

LCA是给定一棵树，动态询问u和v的最近公共祖先。

解决这两种问题都有个很重要的倍增思想（这个思想在后缀数组方面亦有所应用）。

关键需要记住的是

在LCA预处理的时候

p[i,j] 表示i的2^j 倍祖先

那么就有一个递推式子 p[i,j]=p[p[i,j-1],j-1]

RMQ和LCA可以相互转化。。   所以只要记住一种就行了。。

RMQ转LCA的时候是生成一棵类似于堆的递归树；LCA转RMQ的时候用到的是深度优先遍历。

主要掌握的不在于算法，而是在于倍增思想