1.有 3 根柱子（记为 A、B、C）和 n 个大小互不相同的圆盘，所有圆盘初始时都套在柱子 A 上，且圆盘按 “上小下大” 的顺序叠放（大圆盘不能放在小圆盘上方）。要求将所有圆盘从柱子 A 移动到柱子 C，期间可借助柱子 B 作为辅助，每次只能移动 1 个圆盘。请编写程序，输出移动圆盘的每一步操作步骤。

def hanoi(n, source, auxiliary, target):
    """
    递归实现汉诺塔移动
    :param n: 剩余需要移动的圆盘数量
    :param source: 源柱子
    :param auxiliary: 辅助柱子
    :param target: 目标柱子
    """
    if n == 1:
        # 递归终止条件：只有1个圆盘时，直接从源柱移到目标柱
        print(f"移动圆盘1从柱子{source}到柱子{target}")
        return
    # 第一步：把n-1个圆盘从source移到auxiliary（借助target当辅助）
    hanoi(n-1, source, target, auxiliary)
    # 第二步：把最底下的第n个圆盘从source直接移到target
    print(f"移动圆盘{n}从柱子{source}到柱子{target}")
    # 第三步：把n-1个圆盘从auxiliary移到target（借助source当辅助）
    hanoi(n-1, auxiliary, source, target)

# 读取输入：直接读取正整数n（符合题目输入要求）
n = int(input().strip())

# 调用汉诺塔函数，初始源柱A，辅助柱B，目标柱C
hanoi(n, 'A', 'B', 'C')

2.农夫知道一头牛的位置，想要抓住它。农夫和牛都位于数轴上，农夫起始位于点N(0≤N≤100000)，牛位于点K(0≤K≤100000)。农夫有两种移动方式：

1、从X移动到X-1或X+1，每次移动花费一分钟

2、从X移动到2*X，每次移动花费一分钟

假设牛没有意识到农夫的行动，站在原地不动。农夫最少要花多少时间才能抓住牛？

from collections import deque


def min_time_to_catch_cow(N, K):
    # 特殊情况：农夫已经在牛的位置
    if N >= K:
        return N - K

    # 初始化：访问标记数组（0~100000），BFS队列
    max_pos = 100000
    visited = [False] * (max_pos + 1)
    queue = deque()

    # 初始状态：位置N，时间0
    queue.append((N, 0))
    visited[N] = True

    # BFS核心逻辑
    while queue:
        current_pos, time = queue.popleft()

        # 遍历三种移动方式
        # 方式1：X+1
        next1 = current_pos + 1
        if next1 == K:
            return time + 1
        if next1 <= max_pos and not visited[next1]:
            visited[next1] = True
            queue.append((next1, time + 1))

        # 方式2：X-1
        next2 = current_pos - 1
        if next2 == K:
            return time + 1
        if next2 >= 0 and not visited[next2]:
            visited[next2] = True
            queue.append((next2, time + 1))

描述

观察下面的数字金字塔。写一个程序查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以从当前点走到左下方的点也可以到达右下方的点。

3.在上面的样例中,从13到8到26到15到24的路径产生了最大的和86。

输入描述

第一个行包含R(1≤ R≤1000)，表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。

所有的被供应的整数是非负的且不大于100。

输出描述

单独的一行，包含那个可能得到的最大的和。

用例输入

5

13

11 8

12 7  26

6  14 15 8

12 7  13 24 11

用例输出

86

def max_pyramid_sum():
    # 读取行数
    R = int(input())
    # 存储数字金字塔
    pyramid = []
    for _ in range(R):
        row = list(map(int, input().split()))
        pyramid.append(row)

    # 初始化DP数组（直接复用金字塔数组，节省空间）
    dp = pyramid.copy()

    # 从倒数第二行开始向上递推
    for i in range(R - 2, -1, -1):
        # 遍历当前行的每个元素
        for j in range(len(pyramid[i])):
            # 当前值 + 下一行左/右的最大值
            dp[i][j] = pyramid[i][j] + max(dp[i + 1][j], dp[i + 1][j + 1])

    # 顶端的DP值就是最大和
    return dp[0][0]


# 计算并输出结果
print(max_pyramid_sum())