優化最接近的 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