【PAT 甲级】1151 LCA in a Binary Tree （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.Given any two nodes in a binary tree, you are supposed to find their LCA.


最小共同祖先(LCA)是一棵树中两个节点U和V最深的那个公共父节点。要求给一棵树，以及两个节点，请你找出它们的LCA。

输入说明

Each input file contains one test case. For each case, the first line gives two positive integers: M (≤ 1,000), the number of pairs of nodes to be tested; and N (≤ 10,000), the number of keys in the binary tree, respectively. In each of the following two lines, N distinct integers are given as the inorder and preorder traversal sequences of the binary tree, respectively. It is guaranteed that the binary tree can be uniquely determined by the input sequences. Then M lines follow, each contains a pair of integer keys U and V. All the keys are in the range of int.


每个输入包含一个测试用例。

在每个测试用例中，第一行给定两个正整数M和N。M(≤ 1,000)是要查询的节点对数，N (≤ 10,000)是这个二叉树的节点总数。

在这之后的两行分别给定为树的中序遍历和先序遍历。可以保证的是通过这两个序列可以唯一确定一棵二叉树。

接下来的M行为需要查询LCA的M对节点。

树中节点的值皆为整数。

输出说明

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 binary tree, print in a line ERROR: U is not found. or ERROR: V is not found. or ERROR: U and V are not found..


对于给出的一对节点U和V，如果能找到它们的LCA是A，输出：LCA of U and V is A；如果A是U和V之间的某一个，输出：X is an ancestor of Y，其中X是A，而Y代表另外一个节点；

如果U和V没有出现在树中，视情况而定输出：

  • ERROR: U is not found.
  • ERROR: V is not found.
  • ERROR: U and V are not found.

输入示例

6 8
7 2 3 4 6 5 1 8
5 3 7 2 6 4 8 1
2 6
8 1
7 9
12 -3
0 8
99 99

输出示例

LCA of 2 and 6 is 3.
8 is an ancestor of 1.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.

算法

我记得第一次考PAT看到这题时，我很愚蠢地用了以下算法：

  1. 通过中序遍历和先序遍历先建了一棵树；
  2. 声明两个向量Upath和Vpath分别存放两个路径。然后在树中找到U和V的位置，并将路径上的节点依次存入向量；
  3. 从前往后同时遍历两个向量，理论上来说，第一个分叉点是U和V的LCA，当然还夹杂着其中一个节点是否为另一节点的祖先这样的判断。

当然在机考上这题我没有写完，只悲催地得了9分，印象深刻。

后来过了半年，第二次准备考PAT的前一个月时，我刷到这题，还是复制着当时的想法，这次写出来了，29分。我不知道最后1分扣在哪里，很难想出来。写出代码用时40分钟吧，因为在场下，心平气和的。之后考完18年冬季的PAT后再刷Leet-Code的时候遇到这一题，这次不知咋的，可能是刷的题目多了，我没有这么愚蠢了。下面先贴出那个29分的“愚蠢”版

“愚蠢”版

#include <iostream>
#include <vector>
#include <deque>
using namespace std;

typedef struct node
{
    int var;
    struct node *left, *right, *father;
}tree;

int M, N, FindFlag;
tree *T;
vector<int> inorder, preorder;
tree* createTree(tree*, int, int, int, int);
void findLCA(int U, int V);
void findX(int x, tree *p, tree *&Node);

int main() {
    //freopen("/Users/shayue/Desktop/stdin.txt", "r", stdin);
    cin >> M >> N;

    int tmp;
    for(int i = 0; i< N; i++)
    {
        cin >> tmp;
        inorder.push_back(tmp);
    }

    for(int i = 0; i< N; i++)
    {
        cin >> tmp;
        preorder.push_back(tmp);
    }

    int leftOfIn, rightOfIn, leftOfPre, rightOfPre;
    leftOfIn = leftOfPre = 0;
    rightOfIn = rightOfPre = N - 1;
    T = createTree(T, leftOfIn, rightOfIn, leftOfPre, rightOfPre);
    T->father = NULL;

    int U, V;
    int UNotFound, VNotFound;
    for(int i = 0; i < M; i++)
    {
        cin >> U >> V;
        UNotFound = VNotFound = 0;          //标记为0时表明该数不在数组中
                // 下面代码先判断U和V节点是不是在这颗树中
        for(int i = 0; i < preorder.size(); i++)
        {
            if(preorder[i] == U)
                UNotFound = 1;
            if(preorder[i] == V)
                VNotFound = 1;
        }

        if(UNotFound == 0 && VNotFound == 0)
            printf("ERROR: %d and %d are not found.\n", U, V);
        else if(UNotFound == 0)
            printf("ERROR: %d is not found.\n", U);
        else if(VNotFound == 0)
            printf("ERROR: %d is not found.\n", V);
        else
                        // 两个节点都在树中时，进入函数
            findLCA(U, V);
    }
    return 0;
}

tree* createTree(tree* T, int leftOfIn, int rightOfIn, int leftOfPre, int rightOfPre)
{
    int root = preorder[leftOfPre];
    if(leftOfIn < rightOfIn && leftOfPre < rightOfPre)
    {
        int root = preorder[leftOfPre], i;
        T = new tree();
        T->var = root;
        T->left = T->right = NULL;
        leftOfPre = leftOfPre + 1;
                //找到root在中序序列中的下标
        for(i = leftOfIn; i < N && inorder[i] != root; i++);
        int differ = i - leftOfIn;
        T->left = createTree(T->left, leftOfIn, i-1, leftOfPre, leftOfPre+differ-1);
        if(T->left != NULL)
            T->left->father = T;
        T->right = createTree(T->right, i+1, rightOfIn, leftOfPre+differ, rightOfPre);
        if(T->right != NULL)
            T->right->father = T;
    }else if(leftOfIn == rightOfIn && leftOfPre == rightOfPre)
    {
        T = new tree();
        T->var = root;
        T->left = T->right = NULL;
    }
    return T;
}

void findLCA(int U, int V){
    deque<int> UPath, VPath;
    tree *UNode, *VNode;
    FindFlag = 0;
    findX(U, T, UNode);
    FindFlag = 0;
    findX(V, T, VNode);
        // UNode和VNode指向U和V节点在树中的位置，根据father指针找到父节点
    while(UNode != NULL)
    {
        UPath.push_front(UNode->var);
        UNode = UNode->father;
    }
    while(VNode != NULL)
    {
        VPath.push_front(VNode->var);
        VNode = VNode->father;
    }
    int Usize = UPath.size();
    int Vsize = VPath.size();
    if(U == V)
    {
        printf("LCA of %d and %d is %d.\n", U, V, UPath[Usize-2]);
        return;
    }

    int i, j, flag = 0;
    for(i = 0, j = 0; i < Usize && j < Vsize; i++, j++)
    {
        if(UPath[i] != VPath[j])
        {
            flag = 1;
            break;
        }
    }

    if(flag == 0)           //自然而然地走完
    {
        if(i == Usize)
            printf("%d is an ancestor of %d.\n", U, V);
        if(j == Vsize)
            printf("%d is an ancestor of %d.\n", V, U);
    }else
        printf("LCA of %d and %d is %d.\n", U, V, UPath[i-1]);
}

void findX(int x, tree *p, tree *&Node)
{
    if(p)
    {
        if(x == p->var){
            Node = p;
            FindFlag = 1;
            return;
        }
        else
        {
            findX(x, p->left, Node);
            if(FindFlag == 1)
                return;
            findX(x, p->right, Node);
            if(FindFlag == 1)
                return;
        }
    }
}

让我再看一遍这个代码是痛苦的，我都不知道我居然能想出这么多参数来??，包括结构体中增加的一个father指针，指向当前节点的父节点用来寻找路径。

改进

已经给出了中序遍历序列和先序遍历序列了，根本不用建树。

  1. 确定U和V在中序序列中的下标位置，视情况而定输出
  2. U和V都在的情况下，先根据先序遍历序列确定当前寻找范围（数组）内的根节点
  3. 确定根节点在中序遍历中的位置
  4. 比较根节点以及U、V在中序序列中的下标位置，比如刚好根节点在U、V中间，则该根节点便为U、V的LCA；或者根节点与U、V一点重合；或者U和V都在根节点的一侧，此时要缩小范围，重复执行2、3两步。

让我偷懒一次，我就把Leet-Code上面的代码贴上来了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor( vector<TreeNode*> &pre_order, vector<TreeNode*> &in_order, TreeNode* p, TreeNode* q) {
        /*** 利用前序遍历和中序遍历确定p和q的公共祖先  ***/

        // 1.找到p、q两点在中序遍历中的位置，当然Leet-Code这里默认p、q都在树中
        int p_index = -1, q_index = -1;
        for (int i = 0; i < in_order.size(); i++)
        {
            if (p == in_order[i])
                p_index = i;
            if (q == in_order[i])
                q_index = i;
            if (p_index != -1 && q_index != -1)
                break;
        }

/***
        //判断p、q是否都在树中
        if (p_index == -1 && q_index == -1)
        else if(p_index == -1)
        else
***/
        // 2.迭代：找到当前根节点在中序遍历中的下标，根据p、q两点相对于根节点的位置进行判断
        int left_pre = 0, right_pre = in_order.size() - 1;
        int left_in = left_pre, right_in = right_pre;
        while (true)
        {
            // R是当前根节点
            TreeNode *R = pre_order[left_pre];
            // R_index是根节点在中序遍历序列中的下标
            int R_index;
            for(R_index =left_in; in_order[R_index] != R && R_index <= right_in; R_index++);
            if ((p_index - R_index) * (q_index - R_index) <= 0)
                return in_order[R_index];
            else
            {
                // p_index和q_index都在左手边
                if (p_index < R_index)
                {
                    right_pre = R_index - left_in + left_pre;
                    left_pre += 1;
                    right_in = R_index - 1;
                }
                // p_index和q_index都在右手边
                else
                {
                    left_pre = R_index - left_in + left_pre + 1;
                    left_in = R_index + 1;
                }
            }
        }
    }
};

原文地址：https://www.cnblogs.com/shayue/p/10387454.html

时间： 2024-10-04 12:35:05

【PAT 甲级】1151 LCA in a Binary Tree （30 分）的相关文章

PAT 1151 LCA in a Binary Tree[难][二叉树]

1151 LCA in a Binary Tree (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. Given any two nodes in a binary tree, you are supposed to find their LCA. Input Specification:

1127 ZigZagging on a Tree (30 分)

1127 ZigZagging on a Tree (30 分) Suppose that all the keys in a binary tree are distinct positive integers. A unique binary tree can be determined by a given pair of postorder and inorder traversal sequences. And it is a simple standard routine to pr

PAT Advanced 1064 Complete Binary Search Tree (30分)

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 greate

PAT Advanced 1099 Build A Binary Search Tree (30分)

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 greate

PAT Advanced 1102 Invert a Binary Tree (25分)

The following is from Max Howell @twitter: Google: 90% of our engineers use the software you wrote (Homebrew), but you can't invert a binary tree on a whiteboard so fuck off. Now it's your turn to prove that YOU CAN invert a binary tree! Input Specif

04-树6 Complete Binary Search Tree (30 分)

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 greate

7-7 Complete Binary Search Tree (30分)

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 greate

1110 Complete Binary Tree (25分) 判断一棵二插树是否是完全二叉树

Given a tree, you are supposed to tell if it is a complete binary tree. Input Specification: Each input file contains one test case. For each case, the first line gives a positive integer N (≤) which is the total number of nodes in the tree -- and he

【PAT甲级】1099 Build A Binary Search Tree (30 分)

题意: 输入一个正整数N(<=100),接着输入N行每行包括0~N-1结点的左右子结点,接着输入一行N个数表示数的结点值.输出这颗二叉排序树的层次遍历. AAAAAccepted code: 1 #define HAVE_STRUCT_TIMESPEC 2 #include<bits/stdc++.h> 3 using namespace std; 4 pair<int,int>a[107]; 5 int b[107]; 6 int cnt=0; 7 int ans[107]