Python 四和问题解的时间复杂性？

给定一个整数数组，找出所有唯一的四重奏，求和为一个整数 指定的整数

我将在下面提供两种不同的解决方案，我只是想知道哪一种在时间复杂度方面更有效

解决方案1：

def four_sum(arr, s): 
    n = len(arr)
    output = set()

    for i in range(n-2):       
        for j in range(i+1, n-1):
            seen = set()

            for k in range(j+1, n):
                target = s - arr[i] - arr[j] - arr[k]
                if target in seen:
                    output.add((arr[i], arr[j], arr[k], target))

                else:
                    seen.add(arr[k])

    return print('\n'.join(map(str, list(output))))

我知道它的时间复杂度是O（n^3）

解决方案2：

def four_sum2(arr, s):
    n = len(arr)

    seen = {} 
    for i in range(n-1):
        for j in range(i+1, n):
            if arr[i] + arr[j] in seen:
                seen[arr[i] + arr[j]].add((i, j)) 
            else:
                seen[arr[i] + arr[j]] = {(i, j)} 

    output = set()

    for key in seen:
        if s - key in seen:
            for (i, j) in seen[key]:
                for (p, q) in seen[s - key]:
                    sorted_index = tuple(sorted((arr[i], arr[j], arr[p], arr[q]))) 

                    if i not in (p, q) and j not in (p, q): 
                        output.add(sorted_index)

    return output

---

现在，第一个块的时间复杂度为

O（n^2）

，但我不确定第二个块的时间复杂度是多少

TLDR:此算法的复杂性是

O（n^4）

在第一部分中，为所有对

（i，j）

添加了一个元组，其中

j>i

。 因此，正如您所猜测的，

中的元组数大约是
（n-1）*n/2=O（n^2）

第二部分比较复杂。如果我们忽略嵌套循环的第一个条件（临界情况），那么前两个循环可以迭代
中所有可能的元组。因此，复杂性至少是
O（n^2）
。对于第三个循环，它有点棘手：如果不对输入数据进行任何假设，就很难知道复杂性。然而，我们可以假设理论上存在一个临界情况，其中
seen[s-key]
包含
O（n^2）
元组。在这种情况下，整个算法将在
O（n^4）
中运行

这是一个理论上的关键案例吗？
很遗憾，是的。实际上，以具有
s=20的输入
arr=[5，5，…，5，5]
为例。看到的
映射将包含一个键（
10
），该键与
（n-1）*n/2=O（n^2）
元素的数组关联。在这种情况下，第二部分的两个第一个循环将在
O（n^2）
中运行，第三个嵌套循环也将在
O（n^2）
中运行

因此，整个算法在
O（n^4）
中运行

然而，请注意，在实践中，这种情况应该是非常罕见的，并且算法应该在具有许多不同数字的随机输入上运行得更快。如果这个关键病例是固定的（例如，通过单独计算这个病理病例），复杂性可能会提高到
O（n^3）
甚至
O（n^2）