Question

这是我学校过去一年中期论文的问题。下面附有一张图，用于显示机器人如何从同一张纸上移动。我的担忧在橙色部分中说明。

基本上，机器人向前移动，只要遇到左侧未看到的网格方块，就会向左转。

给予机器人横向尺寸为3格的指令序列为：（'F'，'T'，'F'，'T'，'F'，'F'，'T'，'F'，'F'，'T'，'F'，'F'，' F'）其中“F”表示向前移动一个方格，“T”表示向左移动90度。请注意，最后一条指令会导致机器人退出网格。函数gen_seq将网格的大小作为输入，并返回机器人横向网格的指令序列。指令序列是一个包含字符串'F'和'T'的元组，它们代表前进和转向命令。

提供函数gen_seq的递归或迭代实现。提示：Recall int可以与元组相乘。

说明实施时间和空间的增长顺序，并解释您的答案。

这些是markscheme中建议的答案。

def gen_seq(n): # recursive
    if n == 1:
        return ('F',)
    else:
        side = ('T',) + (n-1)*('F',)
        return gen_seq(n-1) + side + side + ('F',)

def gen_seq(n): # iterative
    seq = ('F',)
    for i in range(2, n+1):
        side = ('T',) + (n-1)*('F',)
        seq += side + side + ('F',)
    return seq

时间：O（n ^ 3）。在每个函数调用（递归）或循环（迭代）中，创建螺旋的每个“层”的路径长度的新元组。由于螺旋的长度为n ^ 2，并且有n个函数调用或循环运行n次，因此总时间为n ^ 2 * n = O（n3）。换句话说，它是平方和：1 ^ 2 + 2 ^ 2 + 3 ^ 2 + ::: + n ^ 2 = O（n ^ 3）

空间：O（n ^ 2）。一天结束时，会创建一个大小为n ^ 2的新元组并返回。

1）我是否正确地推断形成元组的时间复杂度的推导似乎是每次递归/迭代之后更新元组的长度的总和。

如果我想形成大小为n ^ 2（拉直螺旋的大小）的元组，则必须首先形成1 ^ 2，然后形成2 ^ 2 ... n ^ 2，从而得到上述平方和。

我在字符串而不是元组上看到了相关的帖子，在这种情况下，时间= 1 + 2 + ... n = n ^ 2，这支持我的推理。

Time complexity of string concatenation in Python

2）对于涉及切片/连接的递归函数的空间复杂度，空间等于它们的时间，在这种情况下是O（n ^ 3），这是正确的。我对这种情况的解释是：由于有n个递归占用了堆栈上的空间，并且每次递归都会形成一个长度为n ^ 2的新元组，这是由连接形成的（这里没有切片），空间将是O（n * N ^ 2）。

我还认为O（n ^ 2）的建议空间仅适用于迭代解决方案，其中没有观察到堆栈帧，并且只有最终元组的长度（n ^ 2）包含在空间中。

Answer 1

TLDR：你的时间复杂性是正确的，尽管递归gen_seq的O（n ^ 3）空间过于悲观（它仍然更加浪费）。请注意，最佳静态解是O（n ^ 2），因为这是答案的大小。如果不需要静态答案，则可以将空间复杂度降低到O（1）。

让我们从建立一些基本的复杂性开始。以下内容适用于时间和空间复杂性：

创建一个字符文字是O（1）。
创建大小为n的元组为O（n）。
- 创建空元素或单元素元组是O（1）。
连接两个长度为n和m的元组为O（n + m）。
- 连接两个长度为n^2和m的元组，它是O（n ^ 2 + m）= O（n ^ 2）。

迭代：

def gen_seq(n): # iterative
    seq = ('F',)
    for i in range(2, n+1):
        side = ('T',) + (i-1)*('F',)  # note: `i-1` instead of `n-1`
        seq += side + side + ('F',)
    return seq

复杂性的关键点是：

range(const, n+1)循环 O（n）时间复杂度， O（1）空间。
对于i-> n，side重新构造为n的大小。重用空间，最多 O（n）空间。对于O（n * n）= O（n ^ 2）时间，所有n次迭代都会消耗时间。
在所有n次迭代中，seq与n元组连接。重用空间，最多为O（n * n）= O（n ^ 2）空间。对于O（n * n ^ 2）= O（n ^ 3）时间，所有n次迭代都消耗时间。

最大的复杂性获胜，因此迭代使用 O（n ^ 2）空间和 O（n ^ 3）时间。

递归：

def gen_seq(n): # recursive
    if n == 1:
        return ('F',)
    else:
        side = ('T',) + (n-1)*('F',)
        return gen_seq(n-1) + side + side + ('F',)

复杂性的关键点是：

从n-> 1重复递归，意味着 O（n）时间。
side重新构建，大小为n。空间未被重用，因为每个side在递归之前构造，最多为O（n * n）= O（n ^ 2））空间。对于O（n * n）= O（n ^ 2）时间，在所有n次迭代中消耗时间。

在所有n次迭代中，return值与n元组连接。空间被重用，因为每个return值在递归之后构造，最多为O（n * n）= O（n ^ 2））空间。对于O（n * n ^ 2）= O（n ^ 3）时间，所有n次迭代都消耗时间。

最大的复杂性获胜，因此迭代使用 O（n ^ 2）空间和 O（n ^ 3）时间。

时间复杂度的限制是每个步骤的结果必须在下一步重复。在Python中，这可以使用生成器来规避 - 这允许您返回中间结果并继续以产生更多结果：

def gen_seq(n): yield 'F' for i in range(1, n): yield 'T' yield from ('F' for _ in range(i)) yield 'T' yield from ('F' for _ in range(i)) seq = tuple(gen_seq(m))

复杂性的关键点是：

range(n)循环 O（n）时间复杂度， O（1）空间。

yield from ... range(i)循环是O（n）时间，O（1）空间。空间重用将其留在 O（1）空间。重复n次得到O（n * n）= O（n ^ 2）时间。

通过tuple一次连接所有结果是O（n ^ 2 * 1）= O（n ^ 2）空间。

最大的复杂性获胜，因此迭代使用O（n ^ 2）空间和O（n ^ 2）时间。如果结果未存储但直接使用，则仅使用O（1）空格。

Python：创建大小n ^ 2元组的时间和空间复杂性

1 个答案: