每日一题（17）树的同构

给定两棵树 T1​ 和 T2​。如果 T1​ 可以通过若干次左右孩子互换就变成 T2​，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。

图1
图2

现给定两棵树，请你判断它们是否是同构的。

输入格式:

输入给出2棵二叉树的信息。对于每棵树，首先在一行中给出一个非负整数 n (≤10)，即该树的结点数（此时假设结点从 0 到 n−1 编号）；随后 n 行，第 i 行对应编号第 i 个结点，给出该结点中存储的 1 个英文大写字母、其左孩子结点的编号、右孩子结点的编号。如果孩子结点为空，则在相应位置上给出 “-”。给出的数据间用一个空格分隔。注意：题目保证每个结点中存储的字母是不同的。

输出格式:

如果两棵树是同构的，输出“Yes”，否则输出“No”。

输入样例1（对应图1）：

8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -

输出样例1:

Yes

输入样例2（对应图2）：

8
B 5 7
F - -
A 0 3
C 6 -
H - -
D - -
G 4 -
E 1 -
8
D 6 -
B 5 -
E - -
H - -
C 0 2
G - 3
F - -
A 1 4

输出样例2:

No

问题分析

要判断两棵树是否同构，我们需要比较它们的结构。因为同构的树允许左右孩子互换，所以在比较时，我们需要考虑两种情况：

1. T₁的左子树与T₂的左子树同构，且T₁的右子树与T₂的右子树同构
2. T₁的左子树与T₂的右子树同构，且T₁的右子树与T₂的左子树同构（即交换左右孩子后同构）

如果上述两种情况有一种成立，那么这两棵树就是同构的。

在实现上，我们首先需要读取输入并构建两棵树，然后找到它们的根节点，最后递归判断它们是否同构。

解题思路

1. 读取输入并构建树：

• 读取节点数量n

• 读取每个节点的信息（值、左孩子、右孩子）

• 构建树的数据结构

     2. 找到树的根节点：

• 根节点是唯一一个不是任何节点的孩子的节点

• 可以用一个布尔数组来标记哪些节点是其他节点的孩子

     3. 递归判断两棵树是否同构：

• 基本情况：如果两个节点都是空，返回true；如果只有一个是空，返回false；如果两个节点的值不相同，返回false

• 递归情况：检查两种可能的情况（不交换左右孩子或交换左右孩子）

代码实现

import java.io.*;
import java.util.*;

public class Main {
    static class TreeNode {
        char val;
        int left;
        int right;
        
        TreeNode(char val, int left, int right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        // 读取第一棵树
        int n1 = Integer.parseInt(br.readLine());
        TreeNode[] tree1 = new TreeNode[n1];
        boolean[] isChild1 = new boolean[n1];
        for (int i = 0; i < n1; i++) {
            String[] parts = br.readLine().split(" ");
            char val = parts[0].charAt(0);
            int left = parts[1].equals("-") ? -1 : Integer.parseInt(parts[1]);
            int right = parts[2].equals("-") ? -1 : Integer.parseInt(parts[2]);
            tree1[i] = new TreeNode(val, left, right);
            if (left != -1) isChild1[left] = true;
            if (right != -1) isChild1[right] = true;
        }
        int root1 = findRoot(isChild1, n1);
        
        // 读取第二棵树
        int n2 = Integer.parseInt(br.readLine());
        TreeNode[] tree2 = new TreeNode[n2];
        boolean[] isChild2 = new boolean[n2];
        for (int i = 0; i < n2; i++) {
            String[] parts = br.readLine().split(" ");
            char val = parts[0].charAt(0);
            int left = parts[1].equals("-") ? -1 : Integer.parseInt(parts[1]);
            int right = parts[2].equals("-") ? -1 : Integer.parseInt(parts[2]);
            tree2[i] = new TreeNode(val, left, right);
            if (left != -1) isChild2[left] = true;
            if (right != -1) isChild2[right] = true;
        }
        int root2 = findRoot(isChild2, n2);
        
        System.out.println(isIsomorphic(root1, tree1, root2, tree2) ? "Yes" : "No");
    }
    
    private static int findRoot(boolean[] isChild, int n) {
        for (int i = 0; i < n; i++) {
            if (!isChild[i]) return i;
        }
        return -1;
    }
    
    private static boolean isIsomorphic(int root1, TreeNode[] tree1, int root2, TreeNode[] tree2) {
        if (root1 == -1 && root2 == -1) return true;
        if (root1 == -1 || root2 == -1) return false;
        if (tree1[root1].val != tree2[root2].val) return false;
        
        return 
            (isIsomorphic(tree1[root1].left, tree1, tree2[root2].left, tree2) && 
             isIsomorphic(tree1[root1].right, tree1, tree2[root2].right, tree2)) ||
            (isIsomorphic(tree1[root1].left, tree1, tree2[root2].right, tree2) && 
             isIsomorphic(tree1[root1].right, tree1, tree2[root2].left, tree2));
    }
}