LeetCode第16题：最接近的三数之和

LeetCode第16题：最接近的三数之和

题目

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

解决方法

这个问题最简单的解决方法就是暴力枚举，使用三重循环选出最优解。

    public int demo(int[] nums, int target){
        int answer = 0;
        int global_error = Integer.MAX_VALUE;
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                for(int k=j+1;k<nums.length;k++){
                    if(Math.abs(nums[i]+nums[j]+nums[k] - target)<global_error){
                        //global_error存储程序运行以来最小的误差，为恒定的正数
                        global_error = Math.abs(nums[i]+nums[j]+nums[k] - target);
                        answer = nums[i]+nums[k]+nums[j];
                    }
                }
            }
        }
        return answer;
    }

提交到LeetCode 上，通过了。

显然这个方法的时间开销是非常大的，时间复杂度达到了O(n^3)。必须想办法降低时间复杂度。

为了充分利用题目中隐含的规律性，应该对数组进行排序。

考虑对于一个固定的a（索引为i），那么现在的任务就是从剩余的元素中选取出b（索引为j，i<j<nums.length）和c（索引为k,j<k<nums.length），使得与a+b+c与target的误差最小。显然，这可以用两重for循环选取出b和c（以上的三重循环就是这样子做的），但是时间复杂度太大了。两重for循环时间复杂度过大的原因是，进行了很多无效的运算。比如，如果a+b+c>target，那么显然a、b和c的值都不应该继续增大，但是如果使用两重for循环的话，在这种情况下也仍然会继续增加c的值。

所以，时间复杂度太大可以归结为，在三重循环的情况下，我们的程序太笨了，即使继续增加c的值不会产生更小的误差也仍然增加c的值。如果我们让start=i+1,end=len-1,b=nums[start],c=nums[end], b从左往右遍历，c从右往左遍历，那么当a、b和c之和大于target时，我们可以令end–，从而缩小c的值；当和小于target时，可以令start++，增大b的值。这样，我们的程序就聪明起来了。

    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int result = Integer.MAX_VALUE;
        int global_error = Integer.MAX_VALUE;
        int len = nums.length;

        for (int i = 0; i < len - 2; i++) {
            //对a进行遍历，a的下标为0 -》 len-3
            int a = nums[i];
            int start = i + 1;  //从左到右遍历
            int end = len - 1;   //从右到左遍历

            while (start < end) {
                int b = nums[start];
                int c = nums[end];
                int cur_error = a + b + c - target;  //abc的和相对于target的误差
                if (Math.abs(cur_error) < Math.abs(global_error)) {
                    result = a + b + c;
                    global_error = cur_error;
                }

                //注意：if语句中的误差是当前的误差而不是全局的误差
                if (cur_error > 0) {
                    //如果global_error大于0，则说明abc的和比error大，
                    // 所以为了缩小误差，应该让c的值减小。
                    //因为nums是从小到大排序的，所以c的索引end应该自减1
                    end--;
                } else if (cur_error == 0) {
                    //global_error等于0是最好的情况，可以直接返回。
                    return a + b + c;
                } else {
                    //global_error小于0，则应该增大abc的和
                    start++;
                }
            }
        }
        return result;
    }

提交到LeetCode上，也通过了。但是执行用时只有三重循环的个位数这么多。

总结

第一，为了充分利用题目中的隐含信息，应该对数组进行排序。

第二，编程时，应该先编写出一个简单可行的程序，然后再在这个基础上做进一步优化。