优化最接近的 3sum 解决方案以避免超出时间限制错误

Question

我正在经历这个最接近的 3-sum leetcode 问题，它说：

给定一个长度为 n 的整数数组 nums 和一个整数目标，在 nums 中找到三个整数，使得总和最接近目标。

返回三个整数的和。

您可以假设每个输入都只有一个解决方案。

我创建了以下解决方案，这看起来是正确的，但它失败并出现Time Limit Exceeded错误。 我该如何优化这段代码？ 我已经添加了我觉得的优化之一，但不确定如何进一步改进。

 class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()

        csum = None
        min_diff = float("+inf")

        for i in range(0,len(nums)-2):
            l = i + 1
            r = len(nums)-1
            
            if i > 0 and nums[i] == nums[i-1]:
                continue # OPTIMIZATION TO AVOID SAME CALCULATION
                
            while l < r:
                sum = nums[i] + nums[l] + nums[r]
                diff = abs(target-sum)
                if sum == target:
                    csum = target
                    min_diff = 0
                    break
                    
                elif sum > target:
                    r -= 1
                else:
                    l += 1
                    
                if min_diff > diff:
                    min_diff = diff
                    csum = sum
                
        return nums[0] if csum is None else csum
                

Answer 1

也许这种参考方法可以提供帮助：先尝试一下，看看您是否有任何问题。 注意 - 从最近的一篇文章中看到这一点，它表现得非常好 - 超过了 Python 类别中提交的 90%。

 def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        return self.kSumClosest(nums, 3, target)

    def kSumClosest(self, nums: List[int], k: int, target: int) -> int:
        N = len(nums)
        if N == k:  return sum(nums[:k])     # found it

        # too small
        tot = sum(nums[:k])
        if tot >= target:  return tot

        # too big
        tot = sum(nums[-k:])
        if tot <= target: return tot
        
        if k == 1:
            return min([(x, abs(target - x)) for x in nums], key = lambda x: x[1])[0]

        closest = sum(nums[:k])
        for i, x in enumerate(nums[:-k+1]):
            if i > 0 and x == nums[i-1]:
                continue
            current = self.kSumClosest(nums[i+1:], k-1, target - x) + x
            if abs(target - current) < abs(target - closest):
                if current == target:
                    return target
                else:
                    closest = current

        return closest