高时间复杂度问题的优化（4Sum）

Question

这是来自 Leetcode 的问题。我根据 3Sum 问题的思想推导出了这个解决方案。

问题是：

给定一个由 n 个整数组成的数组 nums 和一个整数目标，在 nums 中是否存在元素 a、b、c 和 d 使得 a + b + c + d = target？找出数组中所有唯一的四元组，给出目标的总和。

例如

Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

我的解决方案。

class Solution(object):
    def fourSum(self, nums, target):
        answer = []
        nums.sort()
        for i in range(len(nums)-3):
            # print('node 1')
            for j in range(i+1,len(nums)-2):
                # print('node 2')
                k,w = j+1,len(nums)-1
                while k < w:
                    sum = nums[i]+nums[j]+nums[k]+nums[w]
                    if  sum == target and [nums[i],nums[j],nums[k],nums[w]] not in answer:
                        answer.append([nums[i],nums[j],nums[k],nums[w]])
                    if  sum > target:
                        w-=1
                    else:
                        k+=1
        return answer   

但是算法的速度并不理想。

可以做一些小的改变来加速算法吗？

这段代码有冗余吗？ 谢谢

Answer 1

由于我要使用python，所以我宁愿尝试以pythonic的方式来做。

from itertools import combinations

def fourSum(nums, target):
    return list({
        num for num in combinations(nums, 4)
        if sum(num) == target
    })

print(fourSum([1, 0, -1, 0, -2, 2], 0))

为了比较我和你的代码的执行时间，我什至写了下面的脚本。

from itertools import combinations
import timeit, random

def myFourSum(nums, target):
    return list({
        num for num in combinations(nums, 4)
        if sum(num) == target
    })
    
def yourFourSum(nums, target):
    answer = []
    nums.sort()
    for i in range(len(nums)-3):
        # print('node 1')
        for j in range(i+1,len(nums)-2):
            # print('node 2')
            k,w = j+1,len(nums)-1
            while k < w:
                sum = nums[i]+nums[j]+nums[k]+nums[w]
                if  sum == target and [nums[i],nums[j],nums[k],nums[w]] not in answer:
                    answer.append([nums[i],nums[j],nums[k],nums[w]])
                if  sum > target:
                    w-=1
                else:
                    k+=1
    return answer    
    

_list, target = random.sample(range(10000), 10000), random.randint(100, 5000)

setup = "from __main__ import myFourSum"
stmt = f"myFourSum({_list}, {target})"
    
print(myFourSum(_list, target))
print(f"Exec. Time: {timeit.timeit(setup = setup, stmt = stmt, number = 10000)}")

print('-' * 50)

setup = "from __main__ import yourFourSum"
stmt = f"yourFourSum({_list}, {target})"
print(yourFourSum(_list, target))
print(f"Exec. Time: {timeit.timeit(setup = setup, stmt = stmt, number = 10000)}")

我把这个留给你，你应该选择哪一个。

Answer 2

可以做一些小的改变来加速算法。

这是一个问题。

但是是的。您的错误只是 not in answer 测试，因为 answer 是一个列表（列表）。改为将其设为一组（元组）。如果需要，最后转换为列表列表。 （如果你这样做on LeetCode，法官可能会接受不正确的类型。）

这会将您当前的 O(n^6) 解决方案变成 O(n^3) 解决方案。例如：

nums = list(range(50))
target = 98
With list:  0.697 seconds
With set:   0.062 seconds

nums = list(range(100))
target = 198
With list: 48.921 seconds
With set:   0.304 seconds