LeetCode16.最接近的三数之和

题目描述

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

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum-closest

题解

借鉴15题的思路，运用双指针的方法。

1. 特例：如果数组长度小于3，则直接返回
2. 将数组进行排序，这样可以利用一些排序好的性质。而且排序算法时间复杂度为$O(n\log n)$,不会影响整体时间复杂度
3. 遍历数组，设置左右指针$L,R$分别指向$i$的下一位和数组最后一位，确保$L<R$，循环
4. 令$sum=nums[i]+nums[L]+nums[R]$,之后根据$sum$与$target$的距离$diff$求解

代码

golang

func threeSumClosest(nums []int, target int) int {
    n := len(nums)
    if n<3 {
        return 0
    }
    min:= math.MaxInt32
    res := 0
    sort.Ints(nums)
    for i:=0;i<n-2;i++{
        L:=i+1
        R:=n-1
        for L<R{
            sum := nums[i]+nums[L]+nums[R]
            diff:=0
            if sum < target {
                diff=target-sum
                L++
            }else if sum>target{
                diff=sum-target
                R--
            }else {
                return target
            }
            if diff < min {
				min = diff
				res = sum
			}
            
        }
    }
    return res
}

优化–去重

func threeSumClosest(nums []int, target int) int {
    n := len(nums)
    if n<3 {
        return 0
    }
    min:= math.MaxInt32
    res := 0
    sort.Ints(nums)
    for i:=0;i<n-2;i++{
        L:=i+1
        R:=n-1
        for i>0 && i<n-2 && nums[i]==nums[i-1]{
            i++
        }
        for L<R{
            sum := nums[i]+nums[L]+nums[R]
            diff:=0
            if sum < target {
                diff=target-sum
                for L<R && nums[L]==nums[L+1]{
                    L++
                }
                L++
            }else if sum>target{
                diff=sum-target
                for L<R && nums[R]==nums[R-1]{
                    R--
                }
                R--
            }else {
                return target
            }
            if diff < min {
				min = diff
				res = sum
			}
            
        }
    }
    return res
}

虽然在LeetCode的测试中，时间并没有减少，但是实际应用时，尤其是数据量很大时，去重还是很有用的。

再优化

• 当$i$确定下来，由于数组已经排序好，$nums[i]+nums[i+1]+nums[i+2]$就是最小和，$nums[i]+nums[n-1]+nums[n-2]$就是最大和。
• 如果最大和都小于target或最小和都大于target，则其它所有情况与target的距离只会更远，则无需继续进行此次循环
• 其余进行正常的双指针循环

func threeSumClosest(nums []int, target int) int {
    n := len(nums)
    if n<3 {
        return 0
    }
    min:= math.MaxInt32
    res := 0
    sort.Ints(nums)
    for i:=0;i<n-2;i++{
        L:=i+1
        R:=n-1
        sum:=nums[i]+nums[R]+nums[R-1]
        if  sum < target {
            diff := target-sum
            if diff < min {
                res = sum
                min = diff
            }
            continue
        }
        sum = nums[i]+nums[i+1]+nums[i+2]
        if  sum > target {
            diff := sum-target
            if diff < min {
                res = sum
                min = diff
            }
            continue
        }
        for i>0 && i<n-2 && nums[i]==nums[i-1]{
            i++
        }
        for L<R{
            sum = nums[i]+nums[L]+nums[R]
            diff:=0
            if sum < target {
                diff=target-sum
                for L<R && nums[L]==nums[L+1]{
                    L++
                }
                L++
            }else if sum>target{
                diff=sum-target
                for L<R && nums[R]==nums[R-1]{
                    R--
                }
                R--
            }else {
                return target
            }
            if diff < min {
				min = diff
				res = sum
			}
            
        }
    }
    return res
}