【代码随想录算法训练营——Day61】图论——97.小明逛公园、127.骑士的攻击

卡码网题目链接

https://kamacoder.com/problempage.php?pid=1155

https://kamacoder.com/problempage.php?pid=1203

题解
97.小明逛公园

floyd算法用到了动态规划的思想，但感觉还是有点迷糊，python三维数组创建也出现了问题，感觉用动态规划的思想理解问题就是容易不熟悉。

127.骑士的攻击

还可以用广搜写法，真是涨知识（虽然超时了）。这题的代码注释很多，是我看不懂用deepseek写的，其实写了还是看不懂，一知半解，题解写的python语法也有不懂的地方，再加上题目又不懂，就双重不懂。

代码

python 复制代码

#97.小明逛公园
if __name__ == "__main__":
    n, m = map(int, input().split())
    graph = [[[10005] * (n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
    for _ in range(m):
        u, v, w = map(int, input().split())
        graph[u][v][0] = w
        graph[v][u][0] = w
    for k in range(1, n + 1):
        for i in range(1, n + 1):
            for j in range( 1, n + 1):
                graph[i][j][k] = min(graph[i][j][k - 1], graph[i][k][k - 1] + graph[k][j][k - 1])
    Q = int(input())
    for _ in range(Q):
        start, end = map(int, input().split())
        if graph[start][end][n] == 10005:
            print(-1)
        else:
            print(graph[start][end][n])

python 复制代码

#127.骑士的攻击
import heapq
if __name__ == "__main__":
    moves = [(1, 2), (2, 1), (-1, 2), (2, -1), (1, -2), (-2, 1), (-1, -2), (-2, -1)]
    n = int(input())
    def distance(a, b):
        return ((a[0] - b[0]) ** 2 + (a[1] - b [1]) ** 2) ** 0.5
    def bfs(start, end):
        # q 是一个优先队列（通常用最小堆实现）
        # 每个元素是元组: (估算的总代价, 当前节点)

        # distance(start, end) - 启发式函数，估算从start到end的代价
        # start - 当前节点

        # 示例：如果从起点到终点的直线距离是10
        # 那么 q = [(10, 起点)]
        q = [(distance(start, end), start)]
        # step 是一个字典，记录到达每个节点的实际代价（g值）
        # key: 节点
        # value: 从起点到达该节点的实际代价

        # {起点: 0} 表示从起点到起点的实际代价为0
        step = {start : 0}
        while q:
            d, cur = heapq.heappop(q)
            if cur == end:
                return step[cur]
            for move in moves:
                new = (move[0] + cur[0], move[1] + cur[1])
                if 1 <= new[0] <= 1000 and 1 <= new[1] <= 1000:
                    # 计算从起点经过当前节点cur到达新节点new的实际代价
                    # step[cur] - 到达当前节点cur的实际代价（g值）
                    # + 1 - 从cur到new的边代价（这里假设每步代价为1）

                    # 示例：如果到达cur的实际代价是3，那么到达new的实际代价就是4
                    step_new = step[cur] + 1
                    # 检查是否找到了到达new节点的更短路径
                    # step.get(new, float('inf')) - 获取之前到达new的最小代价，如果没访问过则返回无穷大

                    # 如果新路径的代价更小，就更新
                    if step_new < step.get(new, float('inf')):
                        # 更新到达new节点的最小实际代价
                        # 记录新的更优路径
                        step[new] = step_new
                        # 将新节点加入优先队列
                        # distance(new, end) - 启发式估计（h值），从new到终点的估算代价
                        # step_new - 实际代价（g值）
                        # 两者相加就是 f值 = g + h

                        # 队列按f值排序，优先探索f值小的节点
                        heapq.heappush(q, (distance(new, end) + step_new, new))
        return False
    for _ in range(n):
        a1, a2, b1, b2 = map(int, input().split())
        print(bfs((a1, a2), (b1, b2)))