LeetCode——3Sum Closest

最新推荐文章于 2025-07-31 20:29:35 发布

原创最新推荐文章于 2025-07-31 20:29:35 发布 · 529 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

Online Judge 专栏收录该内容

134 篇文章

订阅专栏

探讨了在整数数组中寻找三个数使它们的和最接近给定目标的算法。采用枚举与二分查找相结合的方法，确保每个输入都有唯一解。此问题与经典的3Sum问题相似。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

    For example, given array S = {-1 2 1 -4}, and target = 1.

    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

» Solve this problem

与3Sum类似。

枚举两个数，二分查询第三个数。

假设枚举的前两个数为A[i]和A[j]，查询值为Target-A[i]-A[j]。

查询到某一位置k后，如果A[k] == Target - A[i] - A[j]，则最优解为0。否则需要查看A[i] + A[j] + A[k-1]、A[i] + A[j] + A[k]、A[i] + A[j] + A[k+1]哪一个更加接近Target。

class Solution {
public:
    int threeSumClosest(vector<int> &num, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        sort(num.begin(), num.end());        
        int dis = -1, ans = 0;
        for (int i = 0; i < num.size(); i++) {
            if (i > 0 && num[i] == num[i - 1]) {
                continue;
            }
            for (int j = i + 1; j < num.size(); j++) {
                if (num[j] == num[j - 1] && j - 1 > i) {
                    continue;
                }
                                
                int k = target - num[i] - num[j];
                int left = j + 1, right = num.size() - 1, mid = 0;
                while (left <= right) {
                    mid = (left + right) >> 1;
                    
                    if (num[mid] > k) {                        
                        right = mid - 1;                        
                    } 
                    else if (num[mid] == k) {
                        return target;
                    }
                    else {
                        left = mid + 1;
                    }
                }
                
                if (mid != 0 && (dis < 0 || abs(k - num[mid]) < dis)) {
                    dis = abs(k - num[mid]);
                    ans = target - k + num[mid];
                }
                if (mid > j + 1 && (dis < 0 || abs(k - num[mid - 1]) < dis)) {
                    dis = abs(k - num[mid - 1]);
                    ans = target - k + num[mid - 1];                    
                }
                if (mid < num.size() - 1 && (dis < 0 || abs(k - num[mid + 1]) < dis)) {
                    dis = abs(k - num[mid + 1]);
                    ans = target - k + num[mid + 1];
                }
            }
        }
        return ans;
    }
};