[C++]LeetCode: 15 3Sum Closest (plus JAVA Code)

题目：

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

思路： 寻找数组中三个数的和，满足最接近target

     先对数组进行排序，然后i,j,k三个点。i是最小值，k是最大值，j是中间某值。三个数的和如果大于target，需要左移k,如果小于target，需要右移j。遍历i从最小到最大。
        //此题隐含的意思是可以选择相同的三个整数。所以设计算法时，不需要考虑三个不同整数的约束。

参考：stackoverflow

Attention: 

1. 使用STL里的方法时，必须给出作用域。如 Arrays.sort(num);

2. 对于返回和ans的初始化很重要，不能忘记。还有不能随意初始化，都会影响后面的比较。

3. 遍历i时，只需要到num.length  - 2, 后面是重复的同i，j, k。

4. 注意题目的输入类型java版是数组，C++版是vector.

C++ AC Code:

class Solution {
public:
    int threeSumClosest(vector<int> &num, int target) {
        //寻找数组中三个数的和，满足最接近target
        //思路：先对数组进行排序，然后i,j,k三个点。i是最小值，k是最大值，j是中间某值。三个数的和如果大于target，需要左移k,如果小于target，需要右移j。遍历i从最小到最大。
        //此题隐含的意思是可以选择相同的三个整数。所以设计算法时，不需要考虑三个不同整数的约束。
        
        vector<int> ivec(num.begin(), num.end());
        int ans = 0;
        int sum;
        
        //template <class RandomAccessIterator>
        // void sort (RandomAccessIterator first, RandomAccessIterator last);
        sort(ivec.begin(), ivec.end());
        
        //template <class InputIterator, class T>
        //T accumulate (InputIterator first, InputIterator last, T init); 第三个参数是初值。
        //如果个数小于3个，返回和
        if(ivec.size() < 3)
            return accumulate(ivec.begin(), ivec.end(), 0);
        
        ans = ivec[0] + ivec[1] + ivec[2];  
        
        /* v[0] v[1] v[2] ... v[i] .... v[j] ... v[k] ... v[n-2] v[n-1]
     *                    v[i]  <=  v[j]  <= v[k] always, because we sorted our array. 
     * Now, for each number, v[i] : we look for pairs v[j] & v[k] such that 
     * absolute value of (target - (v[i] + v[j] + v[k]) is minimised.
     * if the sum of the triplet is greater then the target it implies
     * we need to reduce our sum, so we do K = K - 1, that is we reduce
     * our sum by taking a smaller number.
     * Simillarly if sum of the triplet is less then the target then we
     * increase out sum by taking a larger number, i.e. J = J + 1.
     */
     
        //只需要遍历到倒数第三个，倒数一和倒数二是反向重复的。
        for(int i = 0; i < ivec.size() - 2; i++)
        {
            int j = i + 1;
            int k = ivec.size() - 1;
            while(j < k)
            {
                sum = ivec[i] + ivec[j] + ivec[k];
                if(abs(target - ans) > abs(target - sum))
                {
                    ans = sum;
                    if(ans == target)
                        return ans;
                }
                //条件运算符把冒号两边之一作为返回值，所以必须是值，不能是语句
                //(sum > target) ? k-- : j++;   ERROR!!
                //(sum > target) ? k -= 1 : j += 1;
                if(sum > target)
                  k--;
                else
                  j++; 
            }
        }
        
        return ans;
        
    }
};

JAVA AC Code:

public class Solution {
    public int threeSumClosest(int[] num, int target) {
        //先排序，再遍历。
       int ans =0;
       int sum;
       int ArrySize = num.length;
       //需要加上作用域Array才能调用其内的方法
       Arrays.sort(num);
       
       //ans初始化很重要 影响后面比较
       ans = num[0] + num[1] + num[2];
       
       //遍历
       for(int i = 0; i < ArrySize - 2; i++)
       {
           int j = i + 1;
           int k = ArrySize - 1;
           
           while(j < k)
           {
               sum = num[i] + num[j] + num[k];
               
               if( Math.abs(target - ans) > Math.abs(target - sum))
               {
                   ans = sum;
                   //如果距离为0  直接返回ans
                   if(ans == target)
                        return ans;
               }
               //条件运算符把冒号两边之一作为返回值，所以必须是值，不能是语句
               //(sum > target) ? k-- : j++; (sum > target) ? （k -= 1） : （j += 1）;  ERROR!!
              // (sum > target) ? （k -= 1） : （j += 1）;
               if(sum > target)
                  k--;
               else
                  j++; 
           }
       }
       
       //遍历后计算出距离最近的ans
       return ans;
    }
}