题目：判断两幅简单图是否同构 问题描述 给定两个节点数目小于6的简单图，判断这两个简单图是否同构。 输入格式 第一行输入两个简单图的节点数目，第二行开始起分别输入两个简单图的邻接矩阵。 输出格式 若是两幅简单图同构则输出“Yes”，否则输出“No”。

这是一个子图同构问题，可以使用VF2算法来解决。由于题目给出了节点数目小于6的约束条件，因此可以使用暴力枚举的方式来生成所有可能的节点映射，然后使用VF2算法来判断是否存在同构映射。

具体来说，可以按照以下步骤来实现算法：

1. 读入两个简单图的节点数目；
2. 分别读入这两个简单图的邻接矩阵，构建出两个图的图结构；
3. 枚举所有可能的节点映射，对于每一组映射，调用VF2算法来判断是否存在同构映射；
4. 如果存在同构映射，则输出“Yes”并结束程序；否则继续枚举映射，直到所有可能的映射都尝试完毕；
5. 如果程序仍未结束，则输出“No”。

以下是一份Python实现的代码示例：

from itertools import permutations

# 定义图结构
class Graph:
    def __init__(self, n):
        self.n = n
        self.edges = [[] for _ in range(n)]
        self.labels = [0] * n

    def add_edge(self, u, v):
        self.edges[u].append(v)
        self.edges[v].append(u)

# VF2算法实现
def is_isomorphic(g1, g2):
    if g1.n != g2.n:
        return False

    n = g1.n
    m1 = [[False] * n for _ in range(n)]
    m2 = [[False] * n for _ in range(n)]
    l1 = [0] * n
    l2 = [0] * n
    in1 = [0] * n
    in2 = [0] * n
    out1 = [0] * n
    out2 = [0] * n

    # 初始化标签和度数信息
    for i in range(n):
        l1[i] = g1.labels[i]
        l2[i] = g2.labels[i]
        in1[i] = len([j for j in range(n) if m1[j][i]])
        in2[i] = len([j for j in range(n) if m2[j][i]])
        out1[i] = len(g1.edges[i])
        out2[i] = len(g2.edges[i])

    # 判断是否存在同构映射
    def match(u, v):
        for i in range(n):
            if (not m1[u][i] and not m2[v][i] and
                    l1[u] == l2[i] and
                    in1[u] == in2[i] and
                    out1[u] == out2[i]):
                m1[u][i] = m2[v][i] = True

                if u == n - 1:
                    return True

                for j in range(n):
                    if m1[j][i] and match(j, [k for k in g2.edges[i] if not m2[v][k]][0]):
                        return True

                m1[u][i] = m2[v][i] = False

        return False

    return match(0, 0)

# 读入输入数据
n1, n2 = map(int, input().split())
g1 = Graph(n1)
g2 = Graph(n2)

for i in range(n1):
    labels = list(map(int, input().split()))
    g1.labels[i] = labels[i]
    for j in range(i + 1, n1):
        if labels[j] == 1:
            g1.add_edge(i, j)

for i in range(n2):
    labels = list(map(int, input().split()))
    g2.labels[i] = labels[i]
    for j in range(i + 1, n2):
        if labels[j] == 1:
            g2.add_edge(i, j)

# 枚举所有可能的节点映射
for mapping in permutations(range(n1), n1):
    for i in range(n1):
        g1.labels[i] = i
    for i in range(n1):
        for j in range(n1):
            if g1.edges[i][j]:
                g1.edges[i][j] = mapping[j]
    if is_isomorphic(g1, g2):
        print("Yes")
        exit()

print("No")