Python Boggle解算器的时间复杂度

下面是一个（丑陋的）算法，用于查找Boggle中的所有单词：

d = {'cat', 'dog', 'bird'}

grid = [
    ['a', 'd', 'c', 'd'],
    ['o', 'c', 'a', 't'],
    ['a', 'g', 'c', 'd'],
    ['a', 'b', 'c', 'd']
]

found = {}

N = 4

def solve(row, col, prefix):
    if prefix in d and prefix not in found:
        found[prefix] = True
        print prefix

    for i in xrange(max(0, row - 1), min(N, row + 2)):
        for j in xrange(max(0, col - 1), min(N, col + 2)):
            c = grid[i][j]
            if c != '#' and not (row == i and col == j):
                grid[i][j] = '#'
                solve(i, j, prefix + c)
                grid[i][j] = c


for row in xrange(N):
    for col in xrange(N):
        c = grid[row][col]
        grid[row][col] = '#'
        solve(row, col, c)
        grid[row][col] = c

---

这个算法的Big-O运行时是什么？我相信它是

O（（N²）！）

，但我不确定。

求解函数将一个又一个元素转换为

。

，在最坏的情况下，直到整个网格只包含

。

。但是，由于您从网格中的特定点开始，只允许下一个

#

成为直接邻居，因此您无法获得所有

（N²）可能的排列。您只能得到类似于
O（8N2）
，因为网格中的每个节点最多有8个直接邻居。边界处的元素具有较少的邻居，因此可以对此稍加改进

最后的
for
-循环迭代网格中的所有元素并调用solve函数，因此它将是
O（N2⋅8N2）
总计

注意：
8N2
比
（N²）好得多只要
N²≥ 20
，即
N≥ 5

---

注意：我假设

d

只有一个恒定的长度。如果这不是真的，您必须将

d的长度添加到复杂度计算中。
小心d的长度。它是一个常数，但当您搜索d时，它会乘以要求解的调用数。因此，我认为这有可能使大型词典的big-O更糟糕（您可能会在实践中使用）。注意：8N2比（N²）好得多！只要N²≥ 20，即≥ 5.你确定吗？8^25比25..@1.618
8^20~1.15*10^18
和
20！~2.43*10^18
还是我的计算器坏了？