PATA-1151 LCA in a Binary Tree

题意：根据前序和中序建立树，寻找两个点的LCA。

我在之前的博客中写了关于LCA的多种求法。 https://www.cnblogs.com/yy-1046741080/p/11505547.html。  在建树的过程中，建立深度和parent，来寻找LCA。

该题目的数据有一定的欺诈性，它给你结点数据是1-8，如果没有仔细看清题目，那么很有可能定义一个 node tree[10005]的数组，但是题目并没有说数据范围在1-10000内。

经过测试，如果你将范围定义稍微大一点，还是能全过的；

我在这里采用的就是二叉链表，使用二叉链表麻烦的一点在于，需要查找u，v两个结点，返回其指针。

我认为最好的方法就是建立一个映射表，映射输入data和node tree[]中下标的关系，就不需要进行查找。

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

 struct node {
     int data;
     struct node* left, * right;  //left/right=-1,表示空子树
     int depth;
     struct node* parent;
 };

 node* root;  // 树的根
 int pre[];  // 先序遍历序列
 int in[];  // 后序遍历序列
 set<int> is_visit;

 // 先序序列pre[preL,preR],中序序列in[inL,inR],    depth/parent:for LCA;
 node* BuildTree(int preL, int preR, int inL, int inR, int depth, node* parent) {
     if (preL > preR) {
         return NULL;
     }
     node* root = new node;
     root->data = pre[preL];
     root->depth = depth;
     root->parent = parent;
     int k;
     for (k = inL; in[k] != pre[preL]; k++) {
         ;
     }
     root->left = BuildTree(preL + , preL + k - inL, inL, k - , depth + , root);
     root->right = BuildTree(preL + k - inL + , preR, k + , inR, depth + , root);

     return root; // 返回
 }

 // 寻找权值为value的结点
 void find(node* root, int value,node* &t) {
     if (root != NULL) {
         if (root->data == value) {
             t = root;
         }
         else {
             find(root->left, value,t);
             find(root->right, value,t);
         }
     }
 }

 int LCA(int u, int v) {
     node* uu;
     find(root, u, uu);
     node* vv;
     find(root, v, vv);
     while (uu->depth > vv->depth) {
         uu = uu->parent;
     }
     while (uu->depth < vv->depth) {
         vv = vv->parent;
     }
     while (uu != vv) {
         uu = uu->parent;
         vv = vv->parent;
     }
     return uu->data;
 }

 int main() {
     int N, M;
     cin.sync_with_stdio(false);
     cin >> N >> M;
     for (int i = ; i <= M; i++) {
         cin >> in[i];
         is_visit.insert(in[i]);
     }
     for (int i = ; i <= M; i++) {
         cin >> pre[i];
     }
     root = BuildTree(, M, , M, , NULL);
     while (N--) {
         int u, v;
         cin >> u >> v;
         bool f1 = is_visit.find(u) != is_visit.end() ? true : false;
         bool f2 = is_visit.find(v) != is_visit.end() ? true : false;

         if (!f1 && !f2) {
             cout << "ERROR: " << u << " and " << v << " are not found.\n";
         }
         else if (!f1) {
             cout << "ERROR: " << u <<" is not found.\n";
         }
         else if (!f2) {
             cout << "ERROR: " << v <<" is not found.\n";
         }
         else {
             int w = LCA(u, v);
             if (w == u) {
                 cout << u << " is an ancestor of " << v << ".\n";
             }
             else if (w == v) {
                 cout << v << " is an ancestor of " << u << ".\n";
             }
             else {
                 cout << "LCA of " << u << " and " << v << " is " << w << ".\n";
             }
         }
     }
 }