【PAT甲级 - C++题解】1143 Lowest Common Ancestor

✍个人博客：https://blog.csdn.net/Newin2020?spm=1011.2415.3001.5343
📚专栏地址：PAT题解集合
📝原题地址：题目详情 - 1143 Lowest Common Ancestor (pintia.cn)
🔑中文翻译：最低公共祖先
📣专栏定位：为想考甲级PAT的小伙伴整理常考算法题解，祝大家都能取得满分！
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

1143 Lowest Common Ancestor

The lowest common ancestor (LCA) of two nodes U and V in a tree is the deepest node that has both U and V as descendants.

A binary search tree (BST) is recursively defined as a binary tree which has the following properties:

• The left subtree of a node contains only nodes with keys less than the node’s key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
• Both the left and right subtrees must also be binary search trees.

Given any two nodes in a BST, you are supposed to find their LCA.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers: M (≤ 1,000), the number of pairs of nodes to be tested; and N (≤ 10,000), the number of keys in the BST, respectively. In the second line, N distinct integers are given as the preorder traversal sequence of the BST. Then M lines follow, each contains a pair of integer keys U and V. All the keys are in the range of int.

Output Specification:

For each given pair of U and V, print in a line LCA of U and V is A. if the LCA is found and A is the key. But if A is one of U and V, print X is an ancestor of Y. where X is A and Y is the other node. If U or V is not found in the BST, print in a line ERROR: U is not found. or ERROR: V is not found. or ERROR: U and V are not found..

Sample Input:

6 8
6 3 1 2 5 4 8 7
2 5
8 7
1 9
12 -3
0 8
99 99

Sample Output:

LCA of 2 and 5 is 3.
8 is an ancestor of 7.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.

题意

树中两个结点 U 和 V 的最低公共祖先（LCA）是指同时具有 U 和 V 作为后代的最深结点。

二叉搜索树 (BST) 递归定义为具有以下属性的二叉树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
• 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值
• 它的左、右子树也分别为二叉搜索树

现在给定 BST 中的任意两个结点，请你找出它们的最低公共祖先。

第一行输入给定 $M$ 和 $N$ ，表示有 $N$ 个结点和 $M$ 行询问。

第二行给定该二叉树的前序遍历结果。

接下来的 $M$ 行表示要查询的两个结点，需要我们查找这两个结点是否在树中且有公共结点，如果有则输出对应结果。

思路

这道题给定了一个前序遍历的数组，且该树是二叉搜索树，通过二叉搜索树的性质可以知道中序遍历的结果一定是有序的。故我们可以先输入前序遍历数组，然后将其进行排序，就得到了中序遍历的数组。

但是还有一个问题，由于给定的结点值可能存在负数，所以不能直接用 pos 来存储每个结点值在中序遍历中的下标位置，这样会出现数组越界。所以我们要对所有数据进行离散化操作，将所有值的范围缩小到 $0\backsim N-1$ 的范围内，并将中序数组和前序数组中的值进行替换，然后再去构建二叉树。

如下图所示，我们先输入前序数组 pre ，同时将数值也拷贝一份到 seq 中，输入完后进行排序：

这时候的 seq 数组我们可以当做是离散化后的中序数组，然后用哈希表 pos 记录一下每个值离散后对应的结果，其中 key 值是原数组值，value 是离散化之后的值。

这时候，我们再通过离散化后得到的值将 pre 中的值全部替换。

这样我们就得到了离散化后的前序数组和中序数组，然后再进行二叉树的构建，构建二叉树的过程中我们用数组 p 来存储每个结点的父结点。另外，构建的过程中记录一下每个结点所在层数，方便后续的判断。

通过构建可以得到如下二叉树：

构建完二叉树后，就要判断执行查询语句，要分情况况进行讨论。

1. 如果两个结点都在树中，则需要寻找两个结点的最低公共祖先。这里我们采用的方法是从给定的结点往上面进行查找，如果两个结点所在层数不同，则将层数更深的那一个结点往上移一层。如果两结点层数相同，则判断是否相等；如果不想等则两结点同时往上移一层，直到两结点相等为止。

   这样就得到了最低的公共祖先，我们举个例子，假设要查找 1 和 4 的最低公共祖先，注意我们需要先找到给定的值的离散化后的结果，即 0 和 3 。因为树中存储的是离散化后的值，然后再通过上述方法进行查找。

   

   发现 0 在第 2 层而 3 在第 3 层，故 3 需要往上移动一层，来到结点 4 。

   

   此时 0 和 4 所在层数相同，但结点数不相同，故同时往上移动一层，这时候两结点相同，故 2 是 0 和 3 的最低公共祖先。注意，输出结果的时候还要将离散化后的值转换成原值，即输出 1 和 4 的最低公共祖先是 2 。另外，还要注意查询的两结点可能会出现其中一个结点是另一个结点祖先的情况，但查询步骤和上述仍然一样。

   

2. 如果两个结点都不在树中，则直接输出对应语句。注意，不能将该判断放到步骤 3 和步骤 4 好之后，因为可能要查询的两个结点值相同且都不在树中，如果先执行了步骤 3 和步骤 4 会提前打印，但是得到的结果并不是我们想要的。

3. 如果两个结点中第一个结点不在树中，则直接输出对应语句。

4. 如果两个结点中第二个结点不在树中，则直接输出对应语句。

代码

#include<bits/stdc++.h>
using namespace std;

const int N = 10010;
int m, n;
int pre[N], seq[N];
int p[N], depth[N];
unordered_map<int, int> pos;

//二叉树的构建
int build(int il, int ir, int pl, int pr, int d)
{
    int root = pre[pl];   //获得根结点
    int k = root;     //由于数据经历过离散化，所以root等于左子树的结点数

    depth[root] = d;  //记录该结点所在深度

    if (il < k)    p[build(il, k - 1, pl + 1, pl + 1 + k - il - 1, d + 1)] = root; //右子树
    if (ir > k)    p[build(k + 1, ir, pl + 1 + k - il - 1 + 1, pr, d + 1)] = root; //左子树

    return root;
}

int main()
{
    cin >> m >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> pre[i];
        seq[i] = pre[i];
    }

    sort(seq, seq + n);    //获得中序遍历结果
    for (int i = 0; i < n; i++)    pos[seq[i]] = i;  //对每个值进行离散化

    for (int i = 0; i < n; i++)    pre[i] = pos[pre[i]]; //将前序遍历中的值转换成离散后的值

    build(0, n - 1, 0, n - 1, 0);   //构建二叉树

    //查找最低公共祖先
    while (m--)
    {
        int a, b;
        cin >> a >> b;

        if (pos.count(a) && pos.count(b))    //如果两个结点都在树中
        {
            a = pos[a], b = pos[b];  //先转换成离散化后的数值
            int x = a, y = b;    //备份要查找的两个结点

            while (a != b) //找到两个结点的公共结点为止
                if (depth[a] < depth[b])   b = p[b];
                else    a = p[a];

            //打印对应结果
            if (a != x && b != y)  printf("LCA of %d and %d is %d.\n", seq[x], seq[y], seq[a]);
            else if (a == x)   printf("%d is an ancestor of %d.\n", seq[x], seq[y]);
            else    printf("%d is an ancestor of %d.\n", seq[y], seq[x]);
        }
        else if (!pos.count(a) && !pos.count(b))  //如果两个结点都不在树中
            printf("ERROR: %d and %d are not found.\n", a, b);
        else if (!pos.count(a))  //如果第一个结点不在树中
            printf("ERROR: %d is not found.\n", a);
        else  //如果第二个结点不在树中
            printf("ERROR: %d is not found.\n", b);

    }

    return 0;
}