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[10005];  // 先序遍历序列
int in[10005];  // 后序遍历序列
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 + 1, preL + k - inL, inL, k - 1, depth + 1, root);
    root->right = BuildTree(preL + k - inL + 1, preR, k + 1, inR, depth + 1, 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 = 1; i <= M; i++) {
        cin >> in[i];
        is_visit.insert(in[i]);
    }
    for (int i = 1; i <= M; i++) {
        cin >> pre[i];
    }
    root = BuildTree(1, M, 1, M, 1, 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.
";
        }
        else if (!f1) {
            cout << "ERROR: " << u <<" is not found.
";
        }
        else if (!f2) {
            cout << "ERROR: " << v <<" is not found.
";
        }
        else {
            int w = LCA(u, v);
            if (w == u) {
                cout << u << " is an ancestor of " << v << ".
";
            }
            else if (w == v) {
                cout << v << " is an ancestor of " << u << ".
";
            }
            else {
                cout << "LCA of " << u << " and " << v << " is " << w << ".
";
            }
        }
    }
}