门| GATE CS 2021 | 设置 1 | 问题 10

本题是GATE计算机科学考试的第一套试卷中的第十个问题。这道题目考查的是算法和数据结构相关的知识。以下是具体的问题内容与解释。

问题

假设有一个由 $n$ 个节点构成的二叉搜索树（Binary search tree），节点的编号分别为1到 $n$。现在需要对其进行一些操作。操作分两种：

1. 交换一对同级别的节点。换句话说，如果两个节点的父节点相同，则可以交换这两个节点。换完之后，二叉搜索树的特性必须保持不变。
2. 将左子树替换为右子树，或将右子树替换为左子树。

你需要实现一个程序，该程序将根据给定操作序列对二叉搜索树进行修改，最后输出最终的二叉搜索树的根节点编号。

输入格式

第一行包含两个整数 $n$ 和 $q$，表示二叉搜索树的节点数量以及操作序列的数量。

接下来 $n$ 行，每行两个整数 $p$ 和 $q$，表示二叉搜索树节点 $i$ 的左右子节点编号，如果子节点不存在，则编号为0。例如，如果 $p=0$，则表示当前节点没有左子节点。如果 $q=0$，则表示当前节点没有右子节点。根据二叉搜索树的定义，左子节点的值应当比当前节点的值小，右子节点的值应当比当前节点的值大。

接下来 $q$ 行，每行描述一项操作。每项操作都有一个数字 $t$ 和一些参数。

输出格式

输出最终的二叉搜索树的根节点编号。

输入样例

5 2
2 3
1 0
0 0
0 0
4 5
2 3  # 交换节点2和3
1 5  # 将节点1的左子树替换为节点5的右子树

输出样例

4

解释

输入样例表示如下的二叉搜索树。

      2
    /   \
   1     3
        / \
       4   5

首先，我们交换节点2和3，得到以下的结果：

      3
    /   \
   1     2
        / \
       4   5

然后，我们将节点1的左子树替换为节点5的右子树，得到以下的结果：

      3
    /   \
   5     2
        / \
       4   1
            \
             0

最终的结果为节点3。

解题思路

解决这道问题的一个可行的思路是，我们先构建一棵二叉搜索树，然后遍历操作序列，逐个进行操作并修改二叉搜索树。最终，我们返回根节点的编号即可。

首先，我们需要使用输入的数据构建出一棵二叉搜索树，这可以通过将每个节点存储在一个数组中来实现。根据每个节点的编号，我们可以轻松地找到它的左右节点。如果某个节点的左子节点或右子节点不存在，则我们将其赋值为0。

以下是构建二叉搜索树的程序片段：

bst = [None] * (n + 1)
for i in range(1, n + 1):
    p, q = map(int, input().split())
    bst[i] = (p, q)

# 根据给定的节点编号查找其在bst中的位置
def locate(id):
    return bst.index((id, 0)) if (id, 0) in bst else bst.index((id, 0))

接下来，我们可以遍历操作序列中的每个操作，逐个进行修改。对于第一种操作，我们可以直接交换节点即可。对于第二种操作，我们需要将左子树替换为右子树，或将右子树替换为左子树。我们需要注意，替换后的二叉搜索树可能不再满足BST的定义，因此我们需要重新排序节点。以下是操作序列遍历的程序片段：

# 按照输入顺序执行所有操作
for _ in range(q):
    op = input().split()
    t = int(op[0])
    if t == 1:
        x, y = map(int, op[1:])
        px, qx = bst[x]
        py, qy = bst[y]
        if px:
            l = bst.index((px, x))
            bst[l] = (py, x)
        if py:
            l = bst.index((py, y))
            bst[l] = (px, y)
        bst[x] = (py, qy)
        bst[y] = (px, qx)
    else:
        x, y = map(int, op[1:])
        px, qx = bst[x]
        py, qy = bst[y]
        if x == root:
            root = y
        elif y == root:
            root = x
        if px == y or qx == y:
            bst[x] = bst[y]
            bst[y] = (py, qy)
        elif py == x or qy == x:
            bst[y] = bst[x]
            bst[x] = (px, qx)
        else:
            # 替换左子树的情况
            l = bst[:x].count((px, qx))
            bst[l-1] = (y, qy)
            bst[x] = (py, qy)
            bst[y] = (px, qx)
            if l == 1:
                root = y
            else:
                bst[l-2] = (bst[l-2][0], y)  # 修改左边节点的右子树
            if qx:
                r = locate(qx)
                bst[r] = (bst[r][0], y)  # 修改右子树的父节点
        # 排序节点
        bst.sort()

最后，我们返回根节点的编号即可。完整的程序如下所示：

n, q = map(int, input().split())

# 构建二叉搜索树
bst = [None] * (n + 1)
for i in range(1, n + 1):
    p, q = map(int, input().split())
    bst[i] = (p, q)

    # 根据给定的节点编号查找其在bst中的位置
    def locate(id):
        return bst.index((id, 0)) if (id, 0) in bst else bst.index((id, 0))

# 根节点编号为1
root = 1

# 按照输入顺序执行所有操作
for _ in range(q):
    op = input().split()
    t = int(op[0])
    if t == 1:
        x, y = map(int, op[1:])
        px, qx = bst[x]
        py, qy = bst[y]
        if px:
            l = bst.index((px, x))
            bst[l] = (py, x)
        if py:
            l = bst.index((py, y))
            bst[l] = (px, y)
        bst[x] = (py, qy)
        bst[y] = (px, qx)
    else:
        x, y = map(int, op[1:])
        px, qx = bst[x]
        py, qy = bst[y]
        if x == root:
            root = y
        elif y == root:
            root = x
        if px == y or qx == y:
            bst[x] = bst[y]
            bst[y] = (py, qy)
        elif py == x or qy == x:
            bst[y] = bst[x]
            bst[x] = (px, qx)
        else:
            # 替换左子树的情况
            l = bst[:x].count((px, qx))
            bst[l-1] = (y, qy)
            bst[x] = (py, qy)
            bst[y] = (px, qx)
            if l == 1:
                root = y
            else:
                bst[l-2] = (bst[l-2][0], y)  # 修改左边节点的右子树
            if qx:
                r = locate(qx)
                bst[r] = (bst[r][0], y)  # 修改右子树的父节点
        # 排序节点
        bst.sort()

# 返回根节点编号
print(root)

总结

本题考查了算法和数据结构的知识，需要求解二叉搜索树上的节点交换和替换问题。我们可以通过构建一棵二叉搜索树，并按操作序列逐个修改节点来解决这个问题。具体地说，我们需要实现节点的交换和替换操作，并在每次修改后重新排序节点。