Python 汉诺塔

Python3.6.3

递归和非递归两种方法,第三个函数是用来检验步骤正确与否的。 

from typing import List


def hanoi1(n: int, start: int = 0, target: int = 2) -> List[str]:
    """
    递归求解汉诺塔
    共有0,1,2三个柱子
    时间复杂度O(2^n)
    空间复杂度O(2^n)
        因为把整个操作步骤作为列表返回了,长度是2^n-1,所以空间复杂度是O(2^n)
        如果每一步直接打印出来而不是返回步骤列表,那么递归深度是n,空间复杂度是O(n)

    :param n: 汉诺塔层数
    :param start: 起始柱子
    :param target: 目标柱子
    :return: 字符串组成的列表,每个字符串代表一次操作,比如 '0->1' 代表0柱移动到1柱,按顺序操作即可完成移动
    """
    if n is 1:
        return ['%d->%d' % (start, target)]
    other = 3 - start - target
    return hanoi1(n - 1, start, other) + hanoi1(1, start, target) + hanoi1(n - 1, other, target)


def hanoi2(n: int) -> List[str]:
    """
    非递归求解汉诺塔
    时间复杂度O(2^n)
    空间复杂度O(2^n)
        步骤列表的长度是2^n-1
        如果不返回步骤列表,只是打印出来,那么用到了一个长度为n的列表(pillar里面),空间复杂度为O(n)

    非递归说明:
        准备:
            首先把三根柱子按顺序排成品字型,把所有的圆盘按从大到小的顺序放在柱子0上。
            根据圆盘的数量确定柱子的排放顺序
                                                 1
                > 若n为偶数,按顺时针方向依次摆放 0  2;

                                                 2
                > 若n为奇数,按顺时针方向依次摆放 0  1。
        1. 按顺时针方向把最小的圆盘从当前的柱子移动到下一根柱子
        2. 把另外两根柱子上可以移动的圆盘移动到新的柱子上。
            即把非空柱子上的圆盘移动到空柱子上;
            当两根柱子都非空时,移动较小的圆盘。
        3. 反复进行步骤1、2,最后就能按规定完成汉诺塔的移动。
    :param n: 汉诺塔层数
    :return: 字符串组成的列表,每个字符串代表一次操作,比如 '0->1' 代表0柱移动到1柱,按顺序操作即可完成移动
    """
    pillar = [list(range(n + 1, 0, -1)), [n + 1], [n + 1]]  # 三个柱子(均添加一个更大的盘,方便判断步骤2的移动方向)

    # 为步骤1准备好顺序
    # t = n % 2
    # p = (0, t + 1, 2 - t)
    if n % 2 == 1:
        p = (0, 2, 1)
    else:
        p = (0, 1, 2)

    steps = []  # 所有步骤
    j, k = 0, 1  # j,k供步骤1使用:步骤一从p[j]号柱子 移动到 p[k]号柱子
    while True:
        # 1
        steps.append('%d->%d' % (p[j], p[k]))  # 添加步骤
        pillar[p[k]].append(pillar[p[j]].pop())  # 移动
        j = k  # 更新j
        k += 1 if k != 2 else -2  # 更新k

        if len(pillar[-1]) == n + 1:  # 移动完成条件
            break

        # 2
        x, y = set(p) - {p[j]}  # 剩余两个柱子号
        if pillar[x][-1] < pillar[y][-1]:  # 小的向大的移动
            pillar[y].append(pillar[x].pop())  # 移动
            steps.append('%d->%d' % (x, y))  # 添加步骤
        else:
            pillar[x].append(pillar[y].pop())
            steps.append('%d->%d' % (y, x))
    return steps


def move(pillar_0: List[int], pillar_1: List[int], pillar_2: List[int], steps: List[str]):
    """检验函数:按照steps里指定的步骤移动汉诺塔"""
    d = {'0': pillar_0, '1': pillar_1, '2': pillar_2}
    for step in steps:
        d[step[-1]].append(d[step[0]].pop())


def main():
    n = 20
    a = list(range(n, 0, -1))
    b = []
    c = []

    # res1 = hanoi1(n)
    res2 = hanoi2(n)
    # print(res1 == res2)
    
    print(a, b, c)
    move(a, b, c, res2)
    print(a, b, c)


if __name__ == '__main__':
    main()

 

    原文作者: 汉诺塔问题
    原文地址: https://blog.csdn.net/lnotime/article/details/82026382
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞