Python 莱布尼兹行列式公式复杂性

我写了一些代码，用它计算给定nxn矩阵的行列式

我试图用O表示法来解释它的复杂性。 我认为应该是这样的：

O（n！）*O（n^2）+O（n）=O（n！*n^2）

或

O（（n+2）！）

推理：我认为

O（n！）

是排列的复杂性。 而

O（n）

perm_奇偶校验的复杂性，

O（n^2）

是每次迭代n项的乘法

这是我的代码：

def determinant_leibnitz(self):
    assert self.dim()[0] == self.dim()[1] # O(1)
    dim = self.dim()[0] # O(1)
    det,mul = 0,1 # O(1)
    for perm in permutations([num for num in range(dim)]):
        for i in range(dim):
            mul *= self[i,perm[i]] # O(1)
        det += perm_parity(perm)*mul # O(n) ?
        mul = 1 # O(1)
    return det

我编写的以下函数也用于计算：

排列奇偶校验：给定数字0..n按列表顺序排列， 返回其奇偶校验（或符号）：+1表示偶数奇偶校验-奇数为1

我认为perm\u奇偶校验应该运行在

O（n^2）

（正确吗？）

argmin：返回列表中最小参数的索引。 我认为argmin应该运行在

O（n）

（正确吗？）

and排列：返回给定列表的所有排列。 e、 g:输入：[1,2,3]，输出[[1,2,3]，[1,3,2]，[2,1,3]，[2,3,1]，[3,1,2]，[3,2,1]

我认为排列应该运行在

O（n！）

（正确吗？）

def置换（lst）：
如果len（lst）这是一个老问题，但仍然值得回答

您要查找的复杂性是
O（（n+2）！）


这是因为
O（n！）
是这个问题的复杂性：

用于置换中的置换（[num代表范围内的num（dim）]）


O（n）
perm\u奇偶校验函数的复杂性。

O（n^2）
是每次迭代中将
n
项相乘的复杂性。

所有这些都给出了
O（n！）*O（n）*O（n^2）=O（n！n^2）=O（n+2）！

（正如评论所说，在你的例子中，你甚至会得到
O（n+2）！
）
事实上，不仅仅是
O（n！n^2）
，它是
O（n！n^2）
，因为你总是循环所有的排列，并且对于你调用的每个排列
perm_奇偶校验
执行
O（n^2）
操作。为什么O（n^2）要乘以n个数？
def perm_parity(lst):
    parity = 1
    lst = lst[:]
    for i in range(0,len(lst) - 1):
        if lst[i] != i:
            parity *= -1
            mn = argmin(lst[i:]) + i
            lst[i],lst[mn] = lst[mn],lst[i]
    return parity 

def argmin(lst):
    return lst.index(min(lst))

def permutations(lst):
    if len(lst) <= 1:
        return [lst]
    templst = []
    for i in range(len(lst)):
        part = lst[:i] + lst[i+1:]
        for j in permutations(part):
            templst.append(lst[i:i+1] + j)
    return templst