LeetCode第[16]题(Java)：3Sum Closest （和目标值最接近的三个数的和）——Medium

题目难度：Medium

题目：

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.

翻译：

给定一个n个整数的数组S，在S中找到三个整数，使三个数的和最接近目标数，返回三个整数的和。

您可以假设每个输入都有一个确定的答案。

思路：利用3sum里面的算法进行适当调整进行定位。

Code：125 / 125 test cases passed.——27ms(beats 20.85%)　　　　时间复杂度：O(N²)

     public int threeSumClosest(int[] nums, int target) {
         Arrays.sort(nums);
         int result = nums[0] + nums[1] + nums[2];

         for (int i = 0; i < nums.length - 2; i++) {
             if (i > 0 && nums[i] == nums[i-1])
                 continue; // 相邻起点相同的情况已经在上一个点都判断过了

             int left = i + 1;
             int right = nums.length - 1;

             while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right]; // 与3sumy一样

                 if (Math.abs(sum - target) < Math.abs(result - target)) {
                     result = sum;
                 }
                 // 找3sum时，是找确切的相等，所以找到后，三点的值就确定了，不可能有另一个不同的值可以对其中某一个进行替代（只能同时替换两个）；
                 // 但是本题就算找到了也不能去重，因为三点不是确定的，有可能用一个点将三点中某一点进行替代形成更接近的数，所以不能用while去重【其实要去也行，需要加一个绝对值判断，见下面解释】
                 if (sum > target) {
                     right--;
                 } else {
                     left++;
                 }
             }
         }
         return result;
     }

不去重解释：

　　如果去重，假如num[left]与num[left+1]相同，消除了num[i]+num[left]+num[left+1]是‘’最接近的组合‘’可能

其实要去也不是没有办法，那就把这个可能在去重前进行判断记录即可：

                 if (left < right
                         && nums[left] == nums[left + 1]
                         && Math.abs(target - sum) < Math
                                 .abs(target - result)) {
                     result = nums[i] + nums[left] * 2;
                 }
                 if (left < right
                         && nums[right] == nums[right - 1]
                         && Math.abs(target - sum) < Math
                                 .abs(target - result)) {
                     result = nums[i] + nums[right] * 2;
                 }

明显，这种方法仅仅为了那一种情况增加算法复杂度是不明智的，在运行其他测试用例的时候都会慢一点，所以不采用。

参考答案：125 / 125 test cases passed.——26ms(beats 20.85%)　　　　　　　时间复杂度O(N²)

     public int threeSumClosest(int[] num, int target) {
         int result = num[0] + num[1] + num[num.length - 1];
         Arrays.sort(num);
         for (int i = 0; i < num.length - 2; i++) {
             int start = i + 1, end = num.length - 1;
             while (start < end) {
                 int sum = num[i] + num[start] + num[end];
                 if (sum > target) {
                     end--;
                 } else {
                     start++;
                 }
                 if (Math.abs(sum - target) < Math.abs(result - target)) {
                     result = sum;
                 }
             }
         }
         return result;
     }

和我的简直一毛一样

啊哈哈哈哈哈！

没想到，仅仅刷题几天，我已经如此强大了！简直百年难得的刷题奇才呀！

实验室路人甲：明明答案更快点。

朕：切，1ms能叫快嘛，我重新submit一下说不定还20ms了，略

实验室路人甲：那你看人家把nums[i]包括进sum了是不是比你少算几次？

朕：

好吧，确实应该把nums[i]包括进去。。。sum在此算法里应该灵活使用，即需要整体值时使用。

在讨论区还有大神将此题答案优化了一下（去重），好吧肯定不是我的去重那么复杂。。。。

Code：125 / 125 test cases passed.——22ms(beats 62.99%)　　　　　　　时间复杂度O(N²)

     public int threeSumClosest3(int[] nums, int target) {
         Arrays.sort(nums);
         int sum = nums[0] + nums[1] + nums[nums.length - 1];
         int closestSum = sum;

         for(int i = 0; i < nums.length - 2; i++){
             if(i==0 || nums[i]!=nums[i-1]){
                 int left = i + 1, right = nums.length - 1;
                 while(left < right){
                     sum = nums[left] + nums[right] + nums[i];
                     if(sum < target){
                         //move closer to target sum.已经确定sum比target小了，那么相同的left肯定也是小的
                         while(left<right && nums[left] == nums[left+1]){
                             left++;
                         }
                         left++;
                     }else if(sum > target){
                         //move closer to target sum.
                         while(left<right && nums[right] == nums[right-1]){
                             right--;
                         }
                         right--;
                     }else{
                         return sum;
                     }
                     //update the closest sum if needed.
                     if(Math.abs(target - sum) < Math.abs(target - closestSum)){
                         closestSum = sum;
                     }
                 }
             }

         }
         return closestSum;
     }

原来发现在【28行】找到更小值时不能进行去重，可以选择在【11-25行】指针调整的判断里面进行，并且增加了直接返回最优解，厉害厉害