Python 如何计算回溯问题的时间复杂度？_Python_Time Complexity_Backtracking

Python 如何计算回溯问题的时间复杂度？

python time-complexity

Python 如何计算回溯问题的时间复杂度？,python,time-complexity,backtracking,Python,Time Complexity,Backtracking,给定列表列表，打印列表列表列表，其中输出中的每个列表都是输入列表中元素的组合例如： I/P->[['a'、'b']、['c']、['d'、'e'、'f']] o/p->['a'、'c'、'd']、['a'、'c'、'e']、['a'、'c'、'f']、['b'、'c'、'd']、['b'、'c'、'e']、['b'、'c'、'f'] 我已经提出了回溯解决方案。下面是代码。然而，我很难找到它的时间复杂性。我认为它是O（m^n），其中m是给定列表中最长列表的长度，n是给定列表的长度。是这样吗？如何

给定列表列表，打印列表列表列表，其中输出中的每个列表都是输入列表中元素的组合

例如： I/P->[['a'、'b']、['c']、['d'、'e'、'f']]

o/p->['a'、'c'、'd']、['a'、'c'、'e']、['a'、'c'、'f']、['b'、'c'、'd']、['b'、'c'、'e']、['b'、'c'、'f']

我已经提出了回溯解决方案。下面是代码。然而，我很难找到它的时间复杂性。我认为它是O（m^n），其中m是给定列表中最长列表的长度，n是给定列表的长度。是这样吗？如何找到这些回溯问题的时间复杂性

def helper(lists, low, high, temp):
    if len(temp) == high:
        print temp
    for i in range(low, high):
        for j in range(len(lists[i])):
            helper(lists, i+1, high, temp+[lists[i][j]])

if __name__ == "__main__":
    l = [['a','b'],['c'],['d','e','f']]
    helper(l, 0, len(l), [])

有效的做法是重新实现

itertools.product（）

您上面的代码相当于

导入itertools
如果名称=“\uuuuu main\uuuuuuuu”：
l=['a'、'b']、['c']、['d'、'e'、'f']]
l2=itertools.product（*l）
对于l2中的x：
打印（列表（x））

我认为这两种解决方案的时间复杂度都是O（列表数量×列表长度的乘积），但是

itertools.product（）

会快得多，用C编写并适当优化。

您有效地做的是重新实现

itertools.product（）

您上面的代码相当于

导入itertools
如果名称=“\uuuuu main\uuuuuuuu”：
l=['a'、'b']、['c']、['d'、'e'、'f']]
l2=itertools.product（*l）
对于l2中的x：
打印（列表（x））

我认为这两种解决方案的时间复杂度都是O（列表数量×列表长度的乘积），但是

itertools.product（）

将更快，用C编写并适当优化。

对于复杂度问题：

如果有

列出每个长度

n_K

，对于

K=1，…，K

，则需要输出的列表总数为

n_1*n_2*…*n_K

（假设顺序无关紧要）。当

n_1=n_2=…=n_k

或者，我们可以让

N=N_1+…+n_k

是输入列表的不相交并集的大小，并根据

查找边界。对于固定的

，最坏的情况发生在

N_1==N_2

等，我们得到

O（（N/k）^k）

。通过最大化

，我们发现

k=N/e

其中

是欧拉数。因此，我们有

O（e^（1/e）^N）~O（1.44^N）

正如LeopardShark所建议的，您可以查看产品的

itertools

实现以供参考。它不会提高渐近速度，但由于延迟返回，它将更节省空间

更整洁的Python实现可以如下所示：

def custom_product(lsts):
    buf = [[]]
    for lst in lsts:
        buf = [b + [x] for b in buf for x in lst]
    return buf

关于复杂性问题：

如果有