LeetCode 16 - 3Sum Closest

最新推荐文章于 2024-04-29 23:48:08 发布

EnjoyCodingAndGame

最新推荐文章于 2024-04-29 23:48:08 发布

阅读量416

点赞数

分类专栏：编程题目文章标签： C++ LeetCode

本文链接：https://blog.csdn.net/ywcpig/article/details/50389359

版权

编程题目专栏收录该内容

78 篇文章 1 订阅

订阅专栏

3Sum Closest

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).

My Code

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int size = nums.size();
        int result = 0;

        sort(nums.begin(), nums.end());
        int min_dis = INT_MAX;

        for (int i = 0; i < size - 2; i++)
        {
            // Omit duplicate numbers
            if (i > 0 && nums[i] == nums[i-1])
                continue;

            int last_idx = size - 1;
            while (last_idx > i + 1 && nums[i] + nums[i+1] + nums[last_idx] >= target)
                last_idx--;

            // All subsequent sets are increasing and not smaller than target
            if (last_idx == i + 1)
            {
                int sum = nums[i] + nums[i+1] + nums[i+2];
                int cur_dis = abs(sum - target);
                if (min_dis > cur_dis)
                {
                    min_dis = cur_dis;
                    result = sum;
                }
                break;
            }

            int n = last_idx;
            for (int m = i + 1; m < size - 1; m++)
            {
                if (m > i + 1 && nums[m] == nums[m-1])
                    continue;

                // n moves left from last_idx
                while (n > m && nums[i] + nums[m] + nums[n] >= target)
                    n--;

                int small_sum = nums[i] + nums[m] + nums[n], large_sum = small_sum;
                int nn = n + 1;
                while (nn < size && nums[n] == nums[nn])
                    nn++;
                if (nn < size)
                    large_sum = nums[i] + nums[m] + nums[nn];

                int large_sum_dis = abs(large_sum - target), small_sum_dis = abs(small_sum - target);
                if (large_sum_dis < small_sum_dis)
                {
                    if (min_dis > large_sum_dis)
                    {
                        result = large_sum;
                        min_dis = large_sum_dis;
                    }
                }
                else
                {
                    if (min_dis > small_sum_dis)
                    {
                        result = small_sum;
                        min_dis = small_sum_dis;
                    }
                }

                if (min_dis == 0)
                    return result;

                // All subsequent sets are increasing and not smaller than target
                if (nums[i] + nums[m] + nums[n] > target)
                    break;
            }
        }

        return result;
    }
};

Runtime: 16 ms