PAT甲级1143 Lowest Common Ancestor【BST】

题目：https://pintia.cn/problem-sets/994805342720868352/problems/994805343727501312

题意：

给定一个二叉搜索树，以及他的前序遍历序列。

现在有m组询问，对于给定的两个关键字值u，v问他们的最近公共祖先是谁。

思路：

根本跟LCA都没关系好吗。m不是很大，每组询问都查找一次u和v就行了。

因为是BST所以根据前序序列可以直接建出这棵树。

然后在树上查找u和v。

本来还用了一个vector分别存根到u，v的路径，然后两个循环暴力找到最近公共祖先。然后超时了。

其实根本不用这么麻烦，只用在查找的过程中用一个vis数组来标记上一次查找是否已经经过这个点了。如果已经访问过，那么说明这个祖先是他们公共的，更新答案。

因为是从顶开始的遍历所以最后结束时的答案肯定是最近的公共祖先。

 //#include<bits/stdc++>
 #include<stdio.h>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<stdlib.h>
 #include<queue>
 #include<map>
 #include<stack>
 #include<set>

 #define LL long long
 #define ull unsigned long long
 #define inf 0x3f3f3f3f 

 using namespace std;

 int n, m;
 const int maxn = 1e4 + ;
 int preorder[maxn];

 struct node{
     int lchild = -, rchild = -;
     int key;
 }tree[maxn];
 int tot = ;

 bool Insert(int val, int rt)
 {
     if(val < tree[rt].key){
         if(tree[rt].lchild == -){
             tree[tot].key = val;
             tree[rt].lchild = tot++;
             return true;
         }
         else return Insert(val, tree[rt].lchild);
     }
     else if(val > tree[rt].key){
         if(tree[rt].rchild == -){
             tree[tot].key = val;
             tree[rt].rchild = tot++;
             return true;
         }
         else return Insert(val, tree[rt].rchild);
     }
     else return true;
 }

 //vector<int>path[2];
 int vis[maxn], ans;
 bool ffind(int val)
 {
 //    path[u].clear();
     //memset(vis, 0, sizeof(vis));
     int now = ;
     while(now != -){
         if(tree[now].key == val){
             if(vis[now])ans = now;
             else vis[now] = true;
 //            path[u].push_back(now);
             return true;
         }
         else if(val < tree[now].key){
             if(vis[now])ans = now;
             else vis[now] = true;
 //            path[u].push_back(now);
             now = tree[now].lchild;
         }
         else if(val > tree[now].key){
             if(vis[now])ans = now;
             else vis[now] = true;
 //            path[u].push_back(now);
             now = tree[now].rchild;
         }
     }
     if(now == -)return false;
 }

 void printtree(int rt)
 {
     if(rt == -)return;
     printf("%d ", tree[rt].key);
     printtree(tree[rt].lchild);
     printtree(tree[rt].rchild);
     return;
 }

 int main()
 {
     scanf("%d%d", &m, &n);
     tree[].key = inf;
     for(int i = ; i < n; i++){
         scanf("%d", &preorder[i]);
         Insert(preorder[i], );
     }
     //printtree(1);
     while(m--){
         int u, v;
         scanf("%d%d", &u, &v);
         ans = -;
         memset(vis, , sizeof(vis));
         bool fu = ffind(u);
         bool fv = ffind(v);
         if(!fu && !fv){
             printf("ERROR: %d and %d are not found.\n", u, v);
         }
         else if(!fu){
             printf("ERROR: %d is not found.\n", u);
         }
         else if(!fv){
             printf("ERROR: %d is not found.\n", v);
         }
         else{
 //            for(int i = 0; i < path[0].size(); i++)printf("%d ", tree[path[0][i]].key);printf("\n");
 //            for(int j = 0; j < path[1].size(); j++)printf("%d ", tree[path[1][j]].key);printf("\n");

             if(tree[ans].key == u){
                 printf("%d is an ancestor of %d.\n", u, v);
             }
             else if(tree[ans].key == v){
                 printf("%d is an ancestor of %d.\n", v, u);
             }
             else if(ans != -){
                 printf("LCA of %d and %d is %d.\n", u, v, tree[ans].key);
             }
         }
     }

     return ;
 }