leetcode 16. 最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：

3 <= nums.length <= 10^3
-10^3 <= nums[i] <= 10^3
-10^4 <= target <= 10^4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum-closest
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        n = len(nums)
        best = 10**7
        
        def updateSumClosest(cur):
            nonlocal best
            if abs(cur - target) < abs(best - target):
                best = cur
        
        for i in range(n):
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            j, k = i + 1, n - 1
            while j < k:
                s = nums[i] + nums[j] + nums[k]
                if s == target:
                    return target
				#print(s)
                updateSumClosest(s)
                if s > target:
                    k = k - 1
                    while j < k and nums[k] == nums[k + 1]:
                        k -= 1
                else:
                    j = j + 1
                    while j < k and nums[j - 1] == nums[j]:
                        j += 1
        return best

用python3实现的算法解释

best = 10 ** 7

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        global best
        n = len(nums)   #确认列表的长度
        nums.sort()     #对列表做排序处理

        '''更新最接近的三数之和'''
        def updateSumClosest(cur):
            global best
            '''如果当前的三数之和比之前的更接近target则更新'''
            if abs(cur - target) < abs(best - target):
                best = cur

        '''遍历整个数组去查找'''
        for i in range(n):
            '''如果数据相同则直接跳过当前的这个元素，接着查找'''
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            
            '''j的值被赋予i+1，表示的是j从i的下一个有效元素开始做数据比对处理的操作；
            k = n - 1表示的是从最后一个元素往前遍历数据，因为前面已经通过sort()函数
            做了排序的操作，所以从最后一个元素往前看是越来越小的。'''
            j, k = i + 1, n - 1
            '''j的坐标位置小于k的坐标位置'''
            while j < k:
                '''计算三数之和'''
                s = nums[i] + nums[j] + nums[k]
                '''判断三数之和和目标target是否相等,如果相等就直接返回'''
                if s == target:
                    return s
                '''更新获取到的三数之和，判断是否比之前的三数之和更接近target'''
                updateSumClosest(s)
                '''如果三数之和大于目标，则从后往前一直遍历，排除从k坐标往前重复的数据。'''
                if s > target:
                    k0 = k
                    while j < k0 and nums[k0] == nums[k]:
                        k0 -= 1
                    k = k0
                '''如果三数之和小于目标，则从k开始往后一直遍历，排除从j坐标往后重复的数据。'''
                else:
                    j0 = j
                    while j0 < k and nums[j0] == nums[j]:
                        j0 += 1
                    j = j0
                
        return best