【模板】洛谷P3379

例题

题目描述 如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

输入输出格式 输入格式：

第一行包含三个正整数N、M、S，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来N-1行每行包含两个正整数x、y，表示x结点和y结点之间有一条直接连接的边（数据保证可以构成树）。

接下来M行每行包含两个正整数a、b，表示询问a结点和b结点的最近公共祖先。

输出格式：

输出包含M行，每行包含一个正整数，依次为每一个询问的结果。

输入输出样例 输入样例#1：
5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5
输出样例#1：
4
4
1
4
4

说明
时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

样例说明：

该树结构如下：

第一次询问：2、4的最近公共祖先，故为4。

第二次询问：3、2的最近公共祖先，故为4。

第三次询问：3、5的最近公共祖先，故为1。

第四次询问：1、2的最近公共祖先，故为4。

第五次询问：4、5的最近公共祖先，故为4。

故输出依次为4、4、1、4、4。

AC代码(后有详解)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 1e6+5;
struct node
{
    int to,nxt;
}ed[maxn*2];
int tot,head[maxn];
int n,m,s;
void add(int u,int v) 
{
    ed[++tot].to = v;
    ed[tot].nxt = head[u];  
    head[u] = tot;
}
int f[maxn][25],deep[maxn];
int ans[maxn];
void dfs(int u,int p,int d)
{
    f[u][0] = p;
    deep[u] = d;
    for(int i=head[u];i;i=ed[i].nxt) 
    {
        if(ed[i].to != p) 
            dfs(ed[i].to, u, d+1);
    }
}
void init()
{
    dfs(s, -1, 1);
    for(int i=0;i<19;i++) 
        for(int u=1;u<=n;u++)
        {
            if(f[u][i] < 0)
                f[u][i+1] = -1;
            else
                f[u][i+1] = f[f[u][i]][i];
        }
    }
}
int lca(int a,int b)
{
    if(deep[a] > deep[b])
        swap(a,b);
    for(int i=0;i<20;i++)
    {
        if(deep[a] == deep[b])
            break;
        if((deep[b] - deep[a])>>i&1)
            b = f[b][i];
    }
    if(a==b)
        return a;
    for(int i=19;i>=0;i--)
    {
        if(f[a][i] != f[b][i])
        {
            a = f[a][i];
            b = f[b][i];
        }
    }
    return f[a][0];
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    init();
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
    return 0;
}

代码的详解奥

先看看main，主函数里面奥，你会发现有两个add函数的使用，add(x,y)还有add(y,x)。这里用了两次add，因为这个题目里面每一次输入只说了两个数字之间有联系，没说谁上谁下，所以要来两次。
首先来看看add函数

void add(int u,int v) 
{
    ed[++tot].to = v;
    ed[tot].nxt = head[u];  
    head[u] = tot;
}

首先这里的tot是从0开始的，就是第i个。这里的add其实就是我上一篇文章里说的链式前向星了，这里就不多赘述了。不过这里因为两次add函数，所以其实最后的数据其实是两倍，至于为啥两个不会相互影响，这个可以自己想想奥。

接着是说dfs函数，dfs貌似是那个深度算法，这个函数就是上篇讲链式前向星后面那个问题的解决方法。如何寻找父节点。

void dfs(int u,int p,int d)
{
    f[u][0] = p;
    deep[u] = d;
    for(int i=head[u];i;i=ed[i].nxt) 
    {
        if(ed[i].to != p) 
            dfs(ed[i].to, u, d+1);
    }
}

这里的dfs是拿来储存每一个数字的深度，并且从上到下通过找子节点来建立树。因为题目已经告诉你根节点是啥了，就从根节点往下找，并且现在的数字是下一个数字的父节点，这样来储存。(其实还是在用寻找子节点)
注意到了这一步，我们是储存了每个点的深度以及每个点的父节点，先就这两步。找到的父节点储存到f[u][0]里面。

然后是init函数

void init()
{
    dfs(s, -1, 1);
    for(int i=0;i<19;i++) 
        for(int u=1;u<=n;u++)
        {
            if(f[u][i] < 0)
                f[u][i+1] = -1;
            else
                f[u][i+1] = f[f[u][i]][i];
        }
    }
}

首先用了一遍dfs，效果参考上一步。然后每一个数字往上找，其实就是f[u][0]数组不断延申到f[u][n]，一直找到根节点为止。也就是说其实f[u]数组就是储存了从u到根节点的每一步，逆序的。

剩下的其实就简单了，用lca算法来逆序查找需要的f[u]数列。下次再说吧，自己其实有点地方也还是没懂。