1143. Lowest Common Ancestor (30)

1143. Lowest Common Ancestor (30)

 jnxxhzz 分类: PAT  2018-03-19 06:36:34

 所属标签 PAT 甲级

---

• 1143. Lowest Common Ancestor (30)
  • 【分析】
  • 【代码】

1143. Lowest Common Ancestor (30)

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 (<= 1000), the number of pairs of nodes to be tested; and N (<= 10000), 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.

【分析】

题意很简单，给出一颗二叉搜索树的先序遍历，也就是插入顺序，建树，建树后任意给出两个val，先判断这两个val是否在树中，如果都在，则输出这两个val对应点的LCA（最近公共祖先）
建树没什么难度，建完树后判断点是否存在，这里可以用set维护，把树中所有的val插进set直接判断新读取的x,y是否在set中即可，如果用标记数组，就要看到题目中的range in int，是存在负数的，也就是说要用map标记而不能用数组标记
之后就是找LCA，因为数据不难，PAT大纲里也不存在tarjan算法…
所以拿到x,y两个值后，再模拟一遍插入树的过程即可，当出现在某个节点x,y要分别插入到左子树和右子树的时候，当前节点就是这两个值的LCA。
//因为一开始T了一个点，所以我以为是递归爆栈T的，所以把寻找LCA的过程写成了while，后来发现是因为我用数组标记才T的。。

【代码】

#include <bits/stdc++.h>
using namespace std;
struct XX{
    int val,l,r;
}a[1000000];
map<int,int>vis;
void build(int root,int id)
{
    if (a[id].val < a[root].val) //left
    {
        if (a[root].l == -1) a[root].l = id;
        else build(a[root].l,id);
    }
    else //right
    {
        if (a[root].r == -1) a[root].r = id;
        else build(a[root].r,id);
    }
}
int main()
{
    vis.clear();
    int pp,n;scanf("%d%d",&pp,&n); scanf("%d",&a[0].val);a[0].l=a[0].r=-1;vis[a[0].val] = 1;
    for (int i=1;i<n;i++)
    {
        scanf("%d",&a[i].val);
        vis[a[i].val] = 1;
        a[i].l = a[i].r = -1;
        build(0,i);
    }
    int x,y,root;
    while (pp--)
    {
        scanf("%d%d",&x,&y);
        if (!vis[x] && !vis[y])
        {
            printf("ERROR: %d and %d are not found.",x,y);
        }
        else
        if (!vis[x])
        {
            printf("ERROR: %d is not found.",x);
        }
        else
        if (!vis[y])
        {
            printf("ERROR: %d is not found.",y);
        }
        else
        {
            root = 0;
            while (root != -1)
            {
                if (a[root].val == x) break;
                if (a[root].val == y) break;
                if (x<a[root].val && y<a[root].val)
                    root = a[root].l;
                else
                if (x>=a[root].val && y>=a[root].val)
                    root = a[root].r;
                else
                    break;
            }
            if (a[root].val == x) printf("%d is an ancestor of %d.",x,y);else
            if (a[root].val == y) printf("%d is an ancestor of %d.",y,x);else
            printf("LCA of %d and %d is %d.",x,y,a[root].val);
        }
        puts("");
    }
    return 0;
}