LCA 多次询问 解法总结

题目:N个节点,M次询问,求两点间的最近公共祖先


一、并查集+DFS(也叫Tarjan)-------离线O(M+N)


#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
#define N 10100
vector <int> a[N];
int vis[N],fa[N],In[N];
int l,r;
void ini()
{
    for(int i = 0; i < N; i++)a[i].clear();//存树
    for(int i = 0; i < N; i++)vis[i]=0;//存是否被处理过
    for(int i = 0; i < N; i++)fa[i]=i;
    for(int i = 0; i < N; i++)In[i]=0;//存每个节点的入度
}
int get_fa(int x)
{
    if(x==fa[x])return x;
    return fa[x]=get_fa(fa[x]);
}
void LCA(int u)
{
    int len=a[u].size();
    for(int i = 0; i < len; i++)
    {
        int v=a[u][i];
        LCA(v);
        fa[v]=u;
    }
    vis[u]=1;
    if((l==u&&vis[r]))  //此时l,r不在以u为根的子树上,且r那颗子树已经处理完毕,fa[r所在子树的根]=l,r共同的祖先(已经赋过值),所以get_fa(r);
        printf("%d\n",get_fa(r));
    if(r==u&&vis[l])
        printf("%d\n",get_fa(l));//同理
        //printf("haha\n");
}
int  main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        int n;scanf("%d",&n);
        ini();
        for(int i = 1; i < n; i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            a[x].push_back(y);
            In[y]++;
        }
        scanf("%d%d",&l,&r);
       // printf("haha\n");
        for(int i = 1; i <= n; i++)
            if(!In[i])LCA(i);
    }
    return 0;
}


每个节点(比如为x)运行完之后就将x的父指针指向它的父亲(这时父亲节点的父指针依然指向自己),然后再去运行x的兄弟节点,这时兄弟节点下的某个节点(比如y)如果在查询中,且查询如果恰好是(y, x的子孙),则x所在并查集树中的根节点一定是x的父节点,而这个父节点也是y的祖先,因此可知(y, x的子孙)的祖先一定包含x的父节点,由上面过程知道不能可包含比x的父节点更低的祖先节点,因此x的祖先节点必然是(y, x的子孙)的最近公共祖先);


二、裸RMQ--------在线(N(log N)预处理,每次 log N  查询) O(N(log N)+M(log N))

设P[i][j]表示结点i往上移动2^j步所到达的结点,P[i][j]可以通过以下递推公式计算:

P[i][j]=\left\{\begin{matrix} parent(i), j=0 \\P[P[i][j-1]][j-1] \end{matrix}\right.

利用P数组可以快速的将结点i向上移动n步,方法是将n表示为2进制数。比如n=6,二进制为110,那么利用P数组先向上移动4步(2^2),然后再继续移动2步(2^1),即P[ P[i][2] ][1]。

预处理计算P数组代码如下:

map<TreeNode*, int> nodeToId;
map<int, TreeNode*> idToNode;
const int MAXLOGN=20; //树中最大结点数为1<<20
int P[1 << MAXLOGN][MAXLOGN];

//allNodes存放树中所有的结点
void preProcessTree(vector<TreeNode *> allNodes) {
    int n = allNodes.size();
    // 初始化P中所有元素为-1
    for (int i = 0; i < n; i++)
        for (int j = 0; 1 << j < n; j++)
            P[i][j] = -1;
    for (int i = 0; i < n; i++) {
        nodeToId[allNodes[i]] = i;
        idToNode[i] = allNodes[i];
    }
    // P[i][0]=parent(i)
    for (int i = 0; i < n; i++)
        P[i][0] = allNodes[i]->parent ? nodeToId[allNodes[i]->parent] : -1;
    // 计算P[i][j]
    for (int j = 1; 1 << j < n; j++)
        for (int i = 0; i < n; i++)
            if (P[i][j] != -1)
                P[i][j] = P[P[i][j - 1]][j - 1];
}

另外我们还需要预处理计算出每个结点的深度L[],预处理之后,查询node1和node2的LCA算法如下。

TreeNode* getLCA(TreeNode *node1, TreeNode *node2, int L[]) {
    int id1 = nodeToId[node1], id2 = nodeToId[node2];
    //如果node2的深度比node1深,那么交换node1和node2
    if (L[id1] < L[id2]) swap(id1, id2);
    //计算[log(L[id1])]
    int log;
    for (log = 1; 1 << log <= L[id1]; log++);
    log--;
    //将node1向上移动L[id1]-L[id2]步,使得node1和node2在同一深度上
    for (int i = log; i >= 0; i--)
        if (L[id1] - (1 << i) >= L[id2])
            id1 = P[id1][i];
    if (id1 == id2) return idToNode[id1];
    //使用P数组计算LCA(idToNode[id1], idToNode[id2])
    for (i = log; i >= 0; i--)
        if (P[id1][i] != -1 && P[id1][i] != P[id2][i])
            id1 = P[id1][i], id2 = P[id2][i];
    return idToNode[id1];
}

时间复杂度分析:假设树包含n个结点,由于P数组有nlogn个值需要计算,因此预处理的时间复杂度为O(nlogn)。查询两个结点的LCA时,函数getLCA中两个循环最多执行2logn次,因此查询的时间复杂度为O(logn)。

三、LCA转化为RMQ--------在线(N(log N)预处理,每次 O(1)  查询) O(N(log N)+M)


对于有根树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问题的转化方法。

对树进行深度优先遍历,每当“进入”或回溯到某个结点时,将这个结点的编号存入数组E最后一位。同时记录结点i在数组中第一次出现的位置(事实上就是进入结点i时记录的位置),记做R[i]。如果结点E[i]的深度记做D[i],易见,这时求LCA(T,u,v),就等价于求E[RMQ(D,R[u],R [v])],(R[u]<R[v]),其中RMQ(D,R[u],R [v])就是在D数组中求下标从R[u]到R[v]的最小值的下标。例如一,求解步骤如下:

数列E[i]为:1,2,1,3,4,3,5,3,1

R[i]为:1,2,4,5,7

D[i]为:0,1,0,1,2,1,2,1,0

于是有:

LCA(T,5,2) = E[RMQ(D,R[2],R[5])] = E[RMQ(D,2,7)] = E[3] = 1

LCA(T,3,4) = E[RMQ(D,R[3],R[4])] = E[RMQ(D,4,5)] = E[4] = 3

LCA(T,4,5) = E[RMQ(D,R[4],R[5])] = E[RMQ(D,5,7)] = E[6] = 3

易知,转化后得到的数列长度为树的结点数的两倍减一, 所以转化后的RMQ问题与LCA问题的规模同次。

 

 

 

再举一个例子帮助理解:

   (1)

    / \

(2)   (7)

/ \     \

(3) (4)   (8)

    /   \

(5)    (6)

一个nlogn 预处理,O(1)查询的算法.

Step 1:

        按先序遍历整棵树,记下两个信息:结点访问顺序和结点深度.

        如上图:

        结点访问顺序是: 1 2 3 2 4 5 4 6 4 2 1 7 8 7 1 //共2n-1个值

        结点对应深度是: 0 1 2 1 2 3 2 3 2 1 0 1 2 1 0

Step 2:

        如果查询结点3与结点6的公共祖先,则考虑在访问顺序中

        3第一次出现,到6第一次出现的子序列: 3 2 4 5 4 6.

        这显然是由结点3到结点6的一条路径.

        在这条路径中,深度最小的就是最近公共祖先(LCA). 即

        结点2是3和6的LCA.

Step 3:

        于是问题转化为, 给定一个数组R,及两个数字i,j,如何找出

        数组R中从i位置到j位置的最小值..

        如上例,就是R[]={0,1,2,1,2,3,2,3,2,1,0,1,2,1,0}.

        i=2;j=7;

        接下来就是经典的RMQ问题.


#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100010
int cnt,id;
int head[maxn];
bool vis[maxn];
int dep[maxn*2+1], E[maxn*2+1], R[maxn];//R表示节点第一次出现的位置;dep表示时间戳为i时的深度;E表示时间戳为i时的节点
int f[maxn*2+1][20],d[50]; //f[] is RMQ, d[i] is 2^i
struct Edge
{
    int to,next,weight;
}edges[maxn]; //邻接表
void init()
{
    cnt=id=0;
    memset(vis,false,sizeof(vis));
    memset(head,-1,sizeof(head));
}

void insert(int a, int b, int weight)
{
    edges[cnt].to=b;
    edges[cnt].next=head[a];
    edges[cnt].weight=weight;
    head[a]=cnt++;
}
void DFS(int u, int d)
{
    vis[u]=1;
    R[u]=id;E[id]=u;dep[id++]=d;
    for(int i = head[u]; i != -1; i=edges[i].next)
    {
        int v=edges[i].to;
        if(!vis[v])
        {
            DFS(v,d+1);
            E[id]=u;dep[id++]=d;
        }
    }
}
void InitRMQ(const int &id,int n)
{
    d[0]=1;
    for(int i = 1; i < n; i++)d[i]=2*d[i-1];
    for(int i = 0; i < id; i++)f[i][0]=i;
    int k=int(log(double(n))/log(2.0))+1;
    for(int j = 1; j < k; j++)
        for(int i = 0; i < id; i++)
        {
            if(i+d[j-1]-1<id)
                f[i][j]=dep[f[i][j-1]]>dep[f[i+d[j-1]][j-1]]?f[i+d[j-1]][j-1]:f[i][j-1];
            else break;
        }
}
int Query(int x, int y)
{
    int k;
    k=int(log(double(y-x+1))/log(2.0));
    return dep[f[x][k]]>dep[f[y-d[k]+1][k]]?f[y-d[k]+1][k]:f[x][k];
}
void Answer()
{
    int Q;scanf("%d",&Q);
    for(int i = 0; i < Q; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);          //查询x,y的LCA
        x=R[x];y=R[y];
        if(x>y)swap(x,y);
        printf("%d\n",E[Query(x,y)]);
    }
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        init();
        int n,m;scanf("%d%d",&n,&m);
        for(int i = 0; i < m; i++)
        {
            int a,b,c;scanf("%d%d%d",&a,&b,&c);
            insert(a,b,c);
        }
        DFS(1,0);
        InitRMQ(id,n);
        Answer();
    }
    return 0;
}







©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页