PAT a1151

目的：在树上找出两个结点的最低的公共祖先。

数据：

M  小于1000，被测试的节点对数

N  小于10000，树的节点数。

N个节点的整数不同。

中序序列和先序序列。

M个查询。

输出：

如果找到了这个祖先输出："LCA of u and v is a"

如果a是u和v其中的一个输出："x is an ancestor of y";

如果两个节点没找到在树里面，输出：

"ERROR: u is not found."

"ERROR: v is not found."

"ERROR: u and v are not found."

算法思路：两个结点在不在树里面可以当中特殊处理。用一个hash数组储存，如果元素不在就是ERROR:

然后层序遍历这颗树，把每个节点的父亲节点和这个节点是层序遍历的第几个记录下来。

代码：

#include<stdio.h>
#include<queue>
#include<map>

using namespace std;
const int maxn = 10010;
struct node{
    int data;
    node* left,*right;
}*root;
int ans[maxn];//层序遍历的序列
map<int,int> b,e;
int m,n;
int pre[maxn],in[maxn];


node* newnode(int x)
{
    node* now = new node;
    now->data = x;
    now->left = NULL;
    now->right = NULL;
    return now;
}
void creat(node* &root,int pl,int pr,int il,int ir)
{
    if(pl>pr) return;
    int u = pre[pl];
    root = newnode(u);
    int k;
    for(int i=il;i<=ir;i++)
    {
        if(u==in[i])
        {
            k = i;
            break;
        }
    }
    int numleft = k-il;
    creat(root->left,pl+1,pl+numleft,il,il+numleft-1);
    creat(root->right,pl+numleft+1,pr,il+numleft+1,ir);
}
void BFS(node* root)
{
    queue<node*> q;
    q.push(root);
    int num=0;//记录顺序
    b[root->data] = num;
    e[num] = root->data;
    ans[num] = -1;
    num++;
    while(!q.empty())
    {
        node* top = q.front();
        q.pop();
        if(top->left!=NULL)
        {
            node* now = top->left;
            q.push(now);
            b[now->data] = num;
            e[num] = now->data;
            ans[num] = b[top->data];
            num++;
        }
        if(top->right!=NULL)
        {
            node* now = top->right;
            q.push(now);
            b[now->data] = num;
            e[num] = now->data;
            ans[num] = b[top->data];
            num++;
        }
    }
}
void searchf(int u,int v)
{
    int x = b[u];
    int y = b[v];
    while(x!=y)
    {
        if(x>y)
        {
            x = ans[x];
        }else
        {
            y = ans[y];
        }
    }
    if(e[x]==u)
    {
        printf("%d is an ancestor of %d.\n",u,v);
    }else if(e[x]==v)
    {
        printf("%d is an ancestor of %d.\n",v,u);
    }else
    {
        printf("LCA of %d and %d is %d.\n",u,v,e[x]);
    }
}
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&in[i]);
    }
    for(int i=0;i<n;i++)
    {
        scanf("%d",&pre[i]);
    }
    node* root;
    creat(root,0,n-1,0,n-1);
    BFS(root);
    for(int i=0;i<m;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        map<int,int>::iterator itu = b.find(u);
         map<int,int>::iterator itv = b.find(v);
         if(itu==b.end()&&itv==b.end())
         {
            printf("ERROR: %d and %d are not found.\n",u,v);
         }else if(itu==b.end())
         {
            printf("ERROR: %d is not found.\n",u);
         }else if(itv==b.end())
         {
            printf("ERROR: %d is not found.\n",v);
         }else
         {
            searchf(u,v);
         }
    }
    return 0;
}

注意点：注意格式输出。空行空格，要特别注意。begin和end这些最好不要当中变量名字，容易发生冲突。