LeetCode-16-最接近的三数之和

题目

来源：LeetCode.

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

示例 1：

输入：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$

接下来看一下解题思路：

思路：排序 + 双指针：

这个题与三数之和非常类似，不同的是它需要找唯一一个答案，不是列举所有的，所以可以再之前的基础上适当的做一些优化。
    我们使用两层循环来枚举：

• 假设数组的长度为 $n$，我们先枚举 $a$，它在数组中的位置为 $i$；
• 为了防止重复枚举，我们在位置 $[i+1,n)$ 的范围内枚举 $b$ 和 $c$；

    我们使用双指针，用 $p_b$ 和 $p_c$ 分别表示指向 $b$ 和 $c$ 的指针，初始时，$p_b$ 指向位置 $i+1$，即左边界；$p_c$ 指向位置 $n-1$，即右边界。在每一步枚举的过程中，我们用 $a+b+c$ 来更新答案，并且；

• 如果 $a+b+c\ge \text{target}$，那么就将 $p_c$ 向左移动一个位置；
• 如果 $a+b+c<\text{target}$，那么就将 $p_b$ 向右移动一个位置；
      实际上，$p_b$ 和 $p_c$ 就表示了我们当前可以选择的数的范围，而每一次枚举的过程中，我们尝试边界上的两个元素，根据它们与 $\text{target}$ 的值的关系，选择「抛弃」左边界的元素还是右边界的元素，从而减少了枚举的范围。这种思路与 LeetCode-11-盛最多水的容器. 中的双指针解法也是类似的。
      当我们枚举到恰好等于 $\text{target}$ 的 $a+b+c$ 时，可以直接返回 $\text{target}$ 作为答案

    当我们枚举 $a,b,c$ 中任意元素并移动指针时，可以直接将其移动到下一个与这次枚举到的不相同的元素，减少枚举的次数；

public static int threeSumClosest(int[] nums, int target) {
        int count = nums.length;
        // 确保 Math.abs(result - target) 绝对值最大
        int result = 10000000;
        Arrays.sort(nums);
        // 枚举 a
        for (int i = 0; i < count; ++i) {
            // 保证和上一次枚举的元素不相等
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            // 使用双指针枚举 b 和 c
            int j = i + 1;
            int k = count - 1;
            while (k > j) {
                int sum = nums[i] + nums[j] + nums[k];
                // 如果和为 target 直接返回答案
                if (sum == target) {
                    return target;
                }
                // 根据差值的绝对值来更新答案
                if (Math.abs(sum - target) < Math.abs(result - target)) {
                    result = sum;
                }
                if (sum > target) {
                    // 如果和大于 target，移动 c 对应的指针
                    int k0 = k - 1;
                    // 移动到下一个不相等的元素
                    while (j < k0 && nums[k0] == nums[k]) {
                        --k0;
                    }
                    k = k0;
                } else {
                    // 如果和小于 target，移动 b 对应的指针
                    int j0 = j + 1;
                    // 移动到下一个不相等的元素
                    while (j0 < k && nums[j0] == nums[j]) {
                        ++j0;
                    }
                    j = j0;
                }
            }
        }
        return result;
}

总结

    时间复杂度 $O(N^2)$，其中 $N$ 是数组 $\text{nums}$ 的长度；
    空间复杂 $O(logN)$，排序的空间复杂度为 $O(\log N)$。然而我们使用了一个额外的数组存储了 $\text{nums}$ 的副本并进行排序，空间复杂度为 $O(N)$；