PAT 甲级1143 Lowest Common Ancestor (30 分，一个测试点未过）

二叉搜索树中寻找最低公共祖先

最新推荐文章于 2022-09-16 16:58:58 发布

时间领主大锤

最新推荐文章于 2022-09-16 16:58:58 发布

阅读量508

点赞数 1

CC 4.0 BY-SA版权

分类专栏： PAT

本文链接：https://blog.youkuaiyun.com/qq_38846633/article/details/99339886

PAT 专栏收录该内容

34 篇文章

订阅专栏

本文探讨了在二叉搜索树中寻找两个指定节点的最低公共祖先（LCA）的问题，提供了详细的算法解释及代码实现。通过分析先序遍历序列，利用map和set数据结构，有效地解决了LCA查找问题。

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.

这一题是较为简单的lca问题，尽管最后还是有一个测试点超时了（仍然未解决）。这个问题的解决方法便是先手工实现以找到规律，而后采用代码的方法解出。他给出了这个序列是先序序列，而后这个先序序列节点的顺序是左孩子右孩子必须在根节点之后，而且左孩子比根大，右孩子比根小，（这读了好久的题才读懂）。而后，需要做的是找规律，这里找到的规律是其lca首先要在两节点的位置之前，其次，值要在两个节点大小之间。若在两点之前找不到对应的点，则两点是父子关系，出现在前的便是父亲节点。

因此，这里定了两个map（是不是麻烦了些？）一个是下标对数值，另一个是数值对下标，以解决最前公共子节点问题。第二个注意的地方是设置一个set，用来存放输入的数值。以此来确定节点是不是在树内。

完整代码如下（还有超时的一部分不知道怎么改）：

#include <bits/stdc++.h>

using namespace std;

vector <int> pre;

set<int> s;

map<int,int>pos,pos2;

void pre_order(int c,int d)
{
    int pos_c=pos2[c];
    int pos_d=pos2[d];
    int max_p=pos_c<pos_d?pos_c:pos_d;//max_p 用于找出c与d两点哪一个位置在前
    int root=0;
    int flag=0;
    for(int i=1;i<max_p;i++)
    {
        if((pos[i]>c&&pos[i]<d)||(pos[i]<c&&pos[i]>d))
        {
            root=pos[i];
            cout<<"LCA of "<<c<<" and "<<d<<" is "<<root<<"."<<endl;
            flag=1;
            break;
        }
    }
    if(flag==0)
    {
        if(max_p==pos_c)
        {
            cout<<c<<" is an ancestor of "<<d<<"."<<endl;
        }
        else
        {
            cout<<d<<" is an ancestor of "<<c<<"."<<endl;
        }
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    int i=0;
    pre.resize(m+1);
    for(i=1;i<=m;i++)
    {
        cin>>pre[i];
        pos[i]=pre[i];
        pos2[pre[i]]=i;
        s.insert(pre[i]);
    }
    int c,d;
    for(i=1;i<=n;i++)
    {
        cin>>c>>d;
        if(s.find(c)==s.end()&&s.find(d)==s.end())
        {
            cout<<"ERROR: "<<c<<" and "<<d<<" are not found."<<endl;
        }
        else if(s.find(c)!=s.end()&&s.find(d)==s.end())
        {
            cout<<"ERROR: "<<d<<" is not found."<<endl;
        }
        else if(s.find(c)==s.end()&&s.find(d)!=s.end())
        {
            cout<<"ERROR: "<<c<<" is not found."<<endl;
        }
        else
        {
            pre_order(c,d);
        }
    }
    return 0;
}