[PAT] c++ 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.

解析

这道题考察的是搜索二叉树的最低公共祖先，算是一道比较经典的题目了。题目给出了BST的前序遍历，而前序遍历升序排列就是BST的中序遍历了。由前序遍历和中序遍历就可以确定唯一一棵二叉树了。
创建一棵二叉树以后，同时深度搜索U和V，如果出现当前节点等于U或者V，则找到公共祖先。或者U和V分别位于节点node的左右子树，则node为最低公共祖先
考虑到这道题目涉及到值并不在树中，所以读取数据的时候用set或者unordered_set，方便后面查找。
有个小技巧，如果不想写头文件，可以用#include <bits/stdc++.h>，则包含了所有的头文件，但是貌似VS中无法使用

代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <unordered_set>
using namespace std;

struct Tree{
    int val;
    Tree *left,*right;
    Tree(int v):val(v),left(NULL),right(NULL){}
};

void creatTree(Tree* &root,vector<int> &pre,vector<int> &nums,int pl,int pr,int il,int ir){
    if(il>ir||pl>pr) return;
    root=new Tree(pre[pl]);
    int tmp=pre[pl];
    int pos=il;
    while(pos<=ir&&nums[pos]!=tmp){
        pos+=1;
    }
    creatTree(root->left,pre,nums,pl+1,pos-il+pl,il,pos-1);
    creatTree(root->right,pre,nums,pos-il+pl+1,pr,pos+1,ir);
}

void findRes(Tree *root,int u,int v,bool flag){
    if(root==NULL) return;
    if(root->val==u){
        printf("%d is an ancestor of %d.\n",u,v);
        return;
    }
    else if(root->val==v){
        printf("%d is an ancestor of %d.\n",v,u);
        return;
    }
    else if(u>root->val&&v<root->val){
        if(flag==true)
            printf("LCA of %d and %d is %d.\n",u,v,root->val);
        else
            printf("LCA of %d and %d is %d.\n",v,u,root->val);
        return;
    }
    else if(u>root->val&&v>root->val) findRes(root->right,u,v,flag);
    else findRes(root->left,u,v,flag);
}


int main(){
    int m,n;
    scanf("%d%d",&m,&n);
    vector<int> nums(n);
    unordered_set<int> ss;
    for(int i=0;i<n;i++){
        scanf("%d",&nums[i]);
        ss.insert(nums[i]);
    }
    vector<int> preNums=nums;
    sort(nums.begin(),nums.end());
    Tree *root=NULL;
    creatTree(root,preNums,nums,0,n-1,0,n-1);
    for(int i=0;i<m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        if(ss.find(u)==ss.end()&&ss.find(v)==ss.end()){
            printf("ERROR: %d and %d are not found.\n",u,v);
        }
        else if(ss.find(u)==ss.end()){
            printf("ERROR: %d is not found.\n",u);
        }
        else if(ss.find(v)==ss.end()){
            printf("ERROR: %d is not found.\n",v);
        }
        else{
            bool flag=true;
            if(u<=v){
                flag=false;
                swap(u,v);
            }
            findRes(root,u,v,flag);
        }
    }
    return 0;
}