【Rqnoj28】愚蠢的宠物 最近公共祖先

本来想学并查集的，看了黄学长的博客，有道题叫《愚蠢的宠物》，就看了看，然而这道题和并查集并没有多大关系，而是一道最近公共祖先的题，就学了最近公共祖先，以这道题为例，我所了解的求法有3种：

1、是黄学长的方法。记录x和y到每个节点的路径长度，求到每个节点的路径长度和，最小的一个就是答案。代码是黄学长的

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1000005;

int f[maxn], a[maxn], b[maxn], x, y;

int main()
{
    memset(a, 127 / 3, sizeof(a));
    memset(b, 127 / 3, sizeof(b));//不知道为什么是127/3，是把它们都置成707406378，应该是一个比较大但是又不会爆int的数，用memset比用for快 
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        f[i] = i;
    } 

    for (int i = 1; i < n; i++)
    {
        scanf("%d %d", &x, &y);
        f[y] = x;
    }

    scanf("%d %d", &x, &y);

    for (int i = 0; i < n; i++)
    {
        a[x] = min(i, a[x]);//这里为什么不能是a[x] = i? 如果是根节点的话x = f[x], a[x]就会一直+1了 
        x = f[x];
        b[y] = min(i, b[y]);
        y = f[y]; 
    }

    int mn = 999999, ans;
    for (int i = 1; i <= n; i++)
    {
        if (a[i] + b[i] < mn)
        {
            mn = a[i] + b[i];//这里不写mn = min(a[i], b[i])的原因是mn记录的是x和y到i点的路径长度总和，比较的时候比较的是路径长度，而不是最短距离 
            ans = i;
        }
    }

    printf("%d\n", ans);
    return 0;
} 

学到了memset的黑科技用法，但是其实用fill就行了

2、传统的求最近公共祖先的方法。求x和y到根节点的深度，先让深的跳到和浅的一层，然后他们一起向上跳，相遇的那个点就是答案

#include <cstdio>
#include <algorithm>
#include <vector>
#include <climits> //包含各种极限值的头文件 limits 极限 
using namespace std;

const int maxn = 1000005;

int a[maxn], b[maxn], f[maxn] ,dep[maxn];
vector <int> s[maxn];

void depth(int i, int d) //求树的深度 
{
    dep[i] = d;
    for (int j = 0; j < s[i].size(); j++)
    {
        depth(s[i][j], d + 1);
    }
}

int main()
{
    fill(a, a + maxn, INT_MAX / 2);
    fill(b, b + maxn, INT_MAX / 2);

    int n;
    scanf("%d", &n); 

    for (int i = 1; i <= n; i++)
    {
        f[i] = i;
    } 

    for (int i = 1; i < n; i++)
    {
        int x, y;
        scanf("%d %d", &x, &y);
        f[y] = x;
        s[x].push_back(y);
    }

    int x, y; //尽量让一个变量只表示一个意思 
    scanf("%d %d", &x, &y);

    depth(1, 1);//这样就把所有节点的深度都求完了！！！ 

    if (dep[x] < dep[y])
    {
        swap(x, y);
    }

    while (dep[x] > dep[y])
    {
        x = f[x];
    }
    while (x != y)
    {
        x = f[x];
        y = f[y];
    }

    printf("%d\n", x);
    return 0;
}

学到了求树的深度的函数，这个应该经常用
还有一种以2的次方的步伐往上跳的倍增的算法，我不会

3、标记x往上走经过的每一个点，再让y往上走，遇到的第一个被标记的点就是答案

#include <cstdio>
#include <cstring>
const int maxn = 1000005;

int f[maxn];
bool v[maxn];

void dfs(int i) //不是真正的dfs 
{
    if (v[i])
    {
        printf("%d\n", i);
        return;
    }

    v[i] = true;
    if (i != 1)
    {
        dfs(f[i]);
    }
}

int main()
{
    memset(v, false, sizeof(v));
    int n, x, y;
    scanf("%d", &n);
    for (int i = 1; i < n; ++i)
    {
        scanf("%d %d", &x, &y);
        f[y] = x;
    }

    scanf("%d %d", &x, &y);
    dfs(x), dfs(y);
    return 0;
}

代码不是我自己写的