Question

嘿，我无法使用我的代码计算Laplace Expansion的复杂性：

def determinant_laplace(self, i=0):
    assert self.dim()[0] == self.dim()[1]
    if self.dim() == (1,1):
        return self[0,0]
    else:
        det = 0
        for col in range(self.dim()[1]):
            det += ((-1)**(col+i) *self[i,col]* self.minor(i,col).determinant_laplace())
        return det

更好地解决这个问题是如何计算未成年人（在我的代码中）：

def minor(self, i, j):
    t = self.dim()[0] # rows
    k = self.dim()[1] # columns
    assert isinstance(i, int) and isinstance(j, int) \
    and i < t and j < k
    newMat = Matrix(t-1,k-1) # new matrix will be with 1 less col and row
    for row in range(t):
        for col in range(k):
            if row < i and col < j:
                newMat[row,col] = self[row,col]
            elif row < i and col > j:
                newMat[row,col-1] = self[row,col]

            elif row > i and col < j:
                newMat[row-1,col] = self[row,col]

            elif row > i and col > j:
                newMat[row-1,col-1] = self[row,col]
    return newMat

如您所见，在nxn矩阵中创建次要的复杂性为O（n ^ 2）。

所以我被整体复杂性所撕裂是O（n！）还是O（（n + 1）！）或O（（n + 2）！）？

为什么它是O（n！）：维基百科这么说，但我猜他们的实现是不同的，也许他们忽略了一些关于未成年人的计算。

为什么是O（（n + 1））！：递归序列是n（n ^ 2 + next（recursion_minor）..）= O（n * n！）= O（（n + 1）！）

为什么它是O（（n + 2）！）：计算次要是O（n ^ 2），我们计算n！那些我们得到O（n ^ 2）* O（n！）= O（n + 2）！

Personnaly我倾向于 Bold 声明。

感谢您的帮助。

Answer 1

让f(n)成为determinant_laplace完成任务所需的时间大小为n的方形矩阵n。

要计算n个未成年人。

对于每个未成年人

O((n-1)**2) = O(n**2)时间创建未成年人
加上 f(n-1)时间来计算未成年人的determinant_laplace

因此f满足的重现不等式是：

f(n) <= n(C*n**2 + f(n-1))

对于某些C和所有n大于某个常量M。我不知道C和M是什么是的，但我们可以把它们称为恒定值。

考虑假设H(n)：

f(n) <= D * n * n!

表示某个常数D>0，与n无关。

基本案例：对于n = 1, ..., M，我们可以找到一些如此巨大的常量D

H(1), ..., H(M) are true, and D>C.

初步观察：请注意n**3/n! < 1 n >= 6，我们可以假设不失一般性M>6。

归纳步骤：取一些n > M并假设H(n-1)。

f(n) <= n(C*n**2 + f(n-1))          # by our recurrence inequality
     <= C*n**3 + n*D*(n-1)*(n-1)!   # by H(n-1)
      = C*n**3 + D*(n-1)*n!
     <= C*n! + D*(n-1)*n!           # since n**3 / n! < 1 and n > M > 6
      = (C+D*(n-1))*n! 
     <= D*n*n!                      # since D > C

所以H(n)是真的。因此f(n)位于O(n*n!)。

但请注意，这是一个松散的上限。基本上相同的感应证明可用于表明任何f(n) O(n**(1/p)*n!)都在p = 1, 2, 3, ...。

Answer 2

我认为O(n+2)!是正确的答案。正如您所提到的，为大小为ij的Matrix生成次要n x n的复杂性为O(n^2)，它源自代码中的切片（o(k)在python中）。在递归结束时你会得到n！未成年人（大小1 x 1）。所以我们到了这里：

O(n^2) * O(n!) = O(n!(n+1)(n+2)) = O(n+2)!

拉普拉斯展开复杂度计算（递归）

2 个答案: