2023题目代码

一、给定一个矩阵的长宽 m和n，蛇形输出矩阵

def generate_snake_matrix(m, n):
    dx = [-1, 0, 1, 0]
    dy = [0, 1, 0, -1]

    matrix = [[0] * n for _ in range(m)]
    x, y, d = 0, 0, 1

    for i in range(1, m * n + 1):
        matrix[x][y] = i
        a = x + dx[d]
        b = y + dy[d]

        if a < 0 or a >= m or b < 0 or b >= n or matrix[a][b] != 0:
            d = (d + 1) % 4
            a = x + dx[d]
            b = y + dy[d]

        x, y = a, b

    return matrix

m = int(input("输入矩阵的行数 m: "))
n = int(input("输入矩阵的列数 n: "))

matrix = generate_snake_matrix(m, n)
for row in matrix:
    print(' '.join(map(str, row)))

二、给定数字n随后给出n个数，删除出现次数大于等于1的数，输出剩下的数

def remove_repeated(nums):
    # 使用字典统计每个数的出现次数
    count_dict = {}
    for num in nums:
        if num in count_dict:
            count_dict[num] += 1
        else:
            count_dict[num] = 1

    # 仅返回出现次数为1的数
    return [num for num in nums if count_dict[num] == 1]

n = int(input("请输入整数n: "))
nums = list(map(int, input("请输入n个整数，空格分隔: ").split()))

if len(nums) != n:
    print("输入的数字数量与n不符，请检查输入!")
else:
    result = remove_repeated(nums)
    print("剩余的数为:", ' '.join(map(str, result)) if result else "无")

三、给定n个点m条边，随后m行给出顶点和代价，输出最大积的路径

要找到最大积的路径，我们需要遍历所有的路径，并对每个路径上的边的代价进行乘积操作，找出最大值。
我们可以使用深度优先搜索 (DFS) 来遍历所有的路径，并在递归中计算路径的乘积。

输入：
Enter the number of vertices and edges (n m): 3 3
Enter edge 1 (format: u v w):
1 2 2
Enter edge 2 (format: u v w):
2 3 3
Enter edge 3 (format: u v w):
1 3 4
输出：
Maximum product of a path: 6

from collections import defaultdict

class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = defaultdict(list)

    def addEdge(self, u, v, w):
        self.graph[u].append((v, w))
        self.graph[v].append((u, w))

    def maxProductPath(self, start, visited, product=1):
        visited[start] = True
        max_product = product

        for v, w in self.graph[start]:
            if not visited[v]:
                max_product = max(max_product, self.maxProductPath(v, visited, product * w))

        visited[start] = False
        return max_product

n, m = map(int, input().split())
g = Graph(n)

for _ in range(m):
    u, v, w = map(int, input().split())
    g.addEdge(u, v, w)

result = g.maxProductPath(1, [False] * (n + 1))
print(result)

补充：Dijkstra（迪杰斯特拉）算法是一个用于在加权图中查找单源最短路径的算法。该算法主要用于有向和无向图，并且所有边的权重都是非负的。

def dijkstra(matrix, source, target):
    num_vertices = len(matrix)

    # 初始化距离数组和访问集合
    distances = [float('infinity')] * num_vertices
    visited = [False] * num_vertices
    predecessor = [-1] * num_vertices  # 前驱节点数组

    distances[source] = 0

    for _ in range(num_vertices):
        # 从未访问的节点中选择距离最小的节点
        min_distance = float('infinity')
        u = -1
        for i in range(num_vertices):
            if not visited[i] and distances[i] < min_distance:
                # 如果当前节点开销最低且未处理过
                min_distance = distances[i]
                u = i

        # 如果我们已经访问了目标节点，我们可以提前退出
        if u == target:
            break

        # 标记为已访问
        visited[u] = True

        # 更新所有相邻的节点的距离
        for v in range(num_vertices):
            if not visited[v] and matrix[u][v] and distances[u] + matrix[u][v] < distances[v]:
                distances[v] = distances[u] + matrix[u][v]
                predecessor[v] = u

    # 回溯并获取路径
    path = []
    while target != -1:
        path.append(target)
        target = predecessor[target]
    path.reverse()

    return distances[path[-1]], path


# 示例
matrix = [
    [0, 4, 0, 0, 0, 0, 0, 8, 0],
    [4, 0, 8, 0, 0, 0, 0, 11, 0],
    [0, 8, 0, 7, 0, 4, 0, 0, 2],
    [0, 0, 7, 0, 9, 14, 0, 0, 0],
    [0, 0, 0, 9, 0, 10, 0, 0, 0],
    [0, 0, 4, 14, 10, 0, 2, 0, 0],
    [0, 0, 0, 0, 0, 2, 0, 1, 6],
    [8, 11, 0, 0, 0, 0, 1, 0, 7],
    [0, 0, 2, 0, 0, 0, 6, 7, 0]
]

source = 0
target = len(matrix) - 1  # 最后一个节点
distance, path = dijkstra(matrix, source, target)
print(f"Shortest distance from node {source} to node {target}: {distance}")
print(f"Path: {' -> '.join(map(str, path))}")

四、给定树的前序和中序，将树镜像后输出前序和中序（交换树的左右子树）

根据给定的前序和中序遍历结果重建二叉树，并镜像该树，随后输出其前序和中序遍历结果的步骤如下：

1. 使用给定的前序和中序遍历结果重建二叉树。
2. 使用递归的方式镜像该树。
3. 使用递归方式遍历该镜像树得到前序和中序遍历的结果。

输入：
1 2 4 7 3 5 6 8
4 7 2 1 5 3 8 6
输出：
Mirrored Tree Preorder: [1, 3, 6, 8, 5, 2, 4, 7]
Mirrored Tree Inorder: [6, 8, 3, 5, 1, 2, 7, 4]

代码:`

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def buildTree(preorder, inorder):
    if not preorder or not inorder:
        return None
    
    root_val = preorder[0]
    root = TreeNode(root_val)
    
    idx = inorder.index(root_val)
    
    root.left = buildTree(preorder[1:1 + idx], inorder[:idx])
    root.right = buildTree(preorder[1 + idx:], inorder[idx + 1:])
    
    return root

def mirrorTree(root):
    if not root:
        return None
    
    root.left, root.right = root.right, root.left
    mirrorTree(root.left)
    mirrorTree(root.right)

    return root

def preorderTraversal(root):
    return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right) if root else []

def inorderTraversal(root):
    return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right) if root else []

# Input
preorder = list(map(int, input().split()))
inorder = list(map(int, input().split()))

# Build tree
root = buildTree(preorder, inorder)

# Mirror the tree
mirror_root = mirrorTree(root)

# Output the mirrored tree's preorder and inorder traversal results
print("Mirrored Tree Preorder:", preorderTraversal(mirror_root))
print("Mirrored Tree Inorder:", inorderTraversal(mirror_root))