<span style="color:#ff4635">敬請關注部落格，後期不斷更新優質博文，謝謝</span>

package leetcode.T016_threeSumClosest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @Title: Solution.java
 * @Package leetcode.T016_threeSumClosest
 * @Description: TODO
 * @author zhouzhixiang
 * @date 2017-6-7 下午9:05:41
 * @version V1.0
 */
public class Solution {
	/**
	 * <pre>
	 * 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).
	 * 
	 * 題目大意：
	 * 給定包含n個整數陣列S，找到S中的三個整數，從而使之和最接近給定的數。
	 * 返回三個整數的總和。你可以假設每個輸入將有一個確切的解決。
	 * 
	 * 解題思路：
	 * First:讓所有非重複的三個元素之和減去輸入值獲取到他們之間的絕對值，絕對值最小的那一組元素和即為最終結果
	 * </pre>
	 * 
	 * @param nums
	 * @param target
	 * @return
	 */
	public static void main(String[] args) {
		int[] arr = { -1, 2, 1, 0 };
		int s = 1;
		int l = new Solution().threeSumClosest2(arr, s);
		System.out.println(l);
	}

	/**
	 * @Title: threeSumClosest
	 * @Description: zhouzhixiang-First:麻煩，頭腦短路
	 * @param @param arr
	 * @param @param s
	 * @param @return
	 * @return int
	 * @throws
	 */
	public int threeSumClosest(int[] arr, int s) {

		if (arr == null || arr.length == 0) {
			return 0;
		}

		if (s > Integer.MAX_VALUE || s < Integer.MIN_VALUE) {
			return 0;
		}

		int sum = 0;
		String sums = "";
		int result = 0;
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();

		for (int i = 0; i < arr.length - 2; i++) {
			for (int j = i + 1; j < arr.length - 1; j++) {
				for (int z = j + 1; z < arr.length; z++) {
					sum = arr[i] + arr[j] + arr[z];
					// sums += "("+arr[i]+","+arr[j]+","+arr[z]+"),";

					// 記錄下三數之和與輸入值的差的絕對值
					int abs = Math.abs(sum - s);
					// 放入Map集合中,key對應的是兩者之差的絕對值，value對應的是三元素之和
					map.put(abs, sum);
				}
			}
		}

		// 設定個最小數值，
		int min = Integer.MAX_VALUE;

		// 通過迴圈遍歷加判斷獲取到最小的key，key既是兩者之差最小值，則value即為最接近所輸數值的三元素之和
		for (Map.Entry<Integer, Integer> m : map.entrySet()) {
			if (min > m.getKey()) {
				min = m.getKey();
				result = m.getValue();
			}
		}

		return result;
	}

	/**
	 * @Title: threeSumClosest2
	 * @Description: zhouzhixiang-Second：較為簡便
	 * @param @param arr
	 * @param @param s
	 * @param @return
	 * @return int
	 * @throws
	 */
	public int threeSumClosest2(int[] arr, int s) {

		if (arr == null || arr.length == 0) {
			return 0;
		}

		if (s > Integer.MAX_VALUE || s < Integer.MIN_VALUE) {
			return 0;
		}

		// 設定個最小數值，
		int min = Integer.MAX_VALUE;
		// 設定三元素之和
		int sum = 0;
		// 輸出結果
		int result = 0;
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();

		for (int i = 0; i < arr.length - 2; i++) {
			for (int j = i + 1; j < arr.length - 1; j++) {
				for (int z = j + 1; z < arr.length; z++) {
					sum = arr[i] + arr[j] + arr[z];

					// 記錄下三數之和與輸入值的差的絕對值
					int abs = Math.abs(sum - s);
					if (min > abs) {
						min = abs;
						result = sum;
					}
				}
			}
		}

		return result;
	}

	/**
	* @Title: threeSumClosest3 
	* @Description: 參考：值得借鑑：比較簡便
	* @param @param nums
	* @param @param target
	* @param @return    
	* @return int    
	* @throws
	 */
	public int threeSumClosest3(int[] nums, int target) {

		 // 記錄最小的差值
        long minDiff = Long.MAX_VALUE;
        // 記錄最小差值對應的三個整數和和
        long result = 0;
        // 每次求得的差值
        long diff;
        // 每次求得的三個整數的和
        long sum;

        // 先對陣列進行排序
        Arrays.sort(nums);


        // i表示假設取第i個數作為結果
        for (int i = 0; i < nums.length - 2; i++) {
            // 第二個數可能的起始位置
            int j = i + 1;
            // 第三個數可能是結束位置
            int k = nums.length - 1;

            while (j < k) {
                // 求當前三個數的和
                sum = nums[j] + nums[k] + nums[i];
                // 當前和與目標和之間的差值
                diff = Math.abs(target - sum);

                // 差值為0就直接返回
                if (diff == 0) {
                    return (int) sum;
                }

                // 如果當前的差值比之前記錄的差值小
                if (diff < minDiff) {
                    // 更新最小的差值
                    minDiff = diff;
                    // 更新最小差值對應的和
                    result = sum;

                    // 以上的設定在下一次元素處理時生效
                }


                // 和大於target
                if (sum > target) {
                    k--;
                }
                // 和小於target
                else {
                    j++;
                }
            }
        }

        return (int) result;
	}

}
 

歡迎加入Java猿社群