兩數之和，三數之和，最接近的三數之和，四數之和

LeetCode有一系列做法套路相同的題目，N數之和就可以算一個

兩數之和

給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和為目標值的那 兩個 整數，並返回他們的數組下標。

你可以假設每種輸入只會對應一個答案。但是，你不能重復利用這個數組中同樣的元素。

示例:

給定 nums = [2, 7, 11, 15], target = 9

因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

第一個解決辦法，簡單暴力，堆for循環就是，但是，既然在做LeetCode，肯定不能這樣做啊

第二個就是開辟額外的空間來存儲之前出現過的元素，如果之前當前遍歷到的數字和存儲的數字其中一個能夠相加等於target，那么返回兩個數的下標。

public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if(map.containsKey(target-nums[i]))
                return new int[] {map.get(target-nums[i]),i};
            map.put(nums[i], i);
        }
        return new int[] {0,0};
    }

三數之和

給定一個包含 n 個整數的數組 nums，判斷 nums 中是否存在三個元素 a，b，c ，使得 a + b + c = 0 ？找出所有滿足條件且不重復的三元組。

注意：答案中不可以包含重復的三元組。

例如, 給定數組 nums = [-1, 0, 1, 2, -1, -4]，

滿足要求的三元組集合為：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

第一暴力就不多說了。

第二，這道題有一個很需要考慮的地方，就是要去重，我剛開始就是卡在這里，因為我習慣性的思維就是想把所有的答案找出來，然后再從結果集里面去重，后來才發現這樣想着簡單但是實現起來也不容易，因為答案有三個數，判斷三個數重復又是很麻煩的事情，直到看到評論區大佬的代碼，茅塞頓開，采用三指針，判斷后面兩個指針與第一個指針所指的元素的和是否等於target就行，但是這樣帶來一個問題，因為數據是大小分布不均的，那么根據什么條件判斷指針的移動呢，這里就得多出一個排序的時間，先將nums排序然后再根據后面兩個指針的和跟target的大小關系來移動指針，同時，需要判斷指針前后的元素是否相同，是則跳過。從而達到去重的目的。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        if(nums.length<3)
            return ans;
        for(int i = 0;i < nums.length-2;i++){
            if(nums[i]>0)
                return ans;
            if(i>0&&nums[i-1]==nums[i])
                continue;
            for(int j = i+1,k = nums.length-1;j<k;){
                if(j>i+1&&nums[j-1]==nums[j]){
                    j++;
                    continue;
                }
                if(k<nums.length-1&&nums[k+1]==nums[k]){
                    k--;
                    continue;
                }
                int t = nums[i]+nums[j]+nums[k];
                //stem.out.println(t);
                if(t<0)
                    j++;
                else if(t>0)
                    k--;
                else if(t==0){
                    List<Integer> l = new ArrayList<>();
                    l.add(nums[i]);
                    l.add(nums[j++]);
                    l.add(nums[k--]);
                    ans.add(l);
                    
                }
            }
        }
        return ans;
    }
}

最接近的三數之和

給定一個包括 n 個整數的數組 nums 和 一個目標值 target。找出 nums 中的三個整數，使得它們的和與 target 最接近。返回這三個數的和。假定每組輸入只存在唯一答案。

例如，給定數組 nums = [-1，2，1，-4], 和 target = 1.

與 target 最接近的三個數的和為 2. (-1 + 2 + 1 = 2).

跟三數之和差不多的原理，相當於求三數之和和target之差的絕對值的最小值

public class Solution16 {
    public static int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int ans = nums[0]+nums[1]+nums[2];
        for (int i = 0; i < nums.length-2; i++) {
            if(i>0&&nums[i-1]==nums[i])//重復就跳過
                continue;
            //雙指針
            int l = i+1;
            int r = nums.length-1;
            while(l<r) {
                int t = nums[i]+nums[l]+nums[r];
                if(Math.abs(t-target)<Math.abs(ans-target))
                    ans = t;
                if(t>target)
                    r--;
                else if(t<target)
                    l++;
                else 
                    return target;//等於直接返回
                if(l>i+1&&nums[l-1]==nums[l])
                    l++;
                if(r<nums.length-1&&nums[r+1]==nums[r])
                    r--;
                    
            }
        }
        return ans;
    }
    public static void main(String[] args) {
        int[] nums = {1,1,-1,-1,3};
        System.out.println(threeSumClosest(nums, 3));;
    }
}

四數之和

給定一個包含 n 個整數的數組 nums 和一個目標值 target，判斷 nums 中是否存在四個元素 a，b，c 和 d ，使得 a + b + c + d 的值與 target 相等？找出所有滿足條件且不重復的四元組。

注意：

答案中不可以包含重復的四元組。

示例：

給定數組 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

滿足要求的四元組集合為：
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

我的辦法就是由三數之和改進的做法，將第一個數固定，然后判斷這個數后面是否有三數之和。。去重策略也一樣。

先挖個坑在這，回去研究研究，有別的辦法再補上

package com.mine.leetcode;
import java.util.*;
public class Solution18 {
    public List<List<Integer>> fourSum(int[] nums, int target) {
         Arrays.sort(nums);//先排序
         List<List<Integer>> ans = new ArrayList<>();
         if(nums==null||nums.length==0)
             return ans;
         for(int i = 0;i < nums.length-3;i++) {
            if(i>0&&nums[i-1]==nums[i])//去重
                 continue;
             ans.addAll(exitThreeSum(nums,i,target-nums[i]));//找尋此數后面有沒有等於target-自己的數組
         }
         return ans;
     }
     public List<List<Integer>> exitThreeSum(int[] nums,int start,int target) {
         //三數之和的改進
            List<List<Integer>> ans = new ArrayList<>();
            for(int i = start+1;i < nums.length-2;i++){
                if(i>start+1&&nums[i-1]==nums[i])//去重
                    continue;
                for(int j = i+1,k = nums.length-1;j<k;){
                    if(j>i+1&&nums[j-1]==nums[j]){//去重
                        j++;
                        continue;
                    }
                    if(k<nums.length-1&&nums[k+1]==nums[k]){//去重
                        k--;
                        continue;
                    }
                    int t = nums[i]+nums[j]+nums[k];
                    if(t<target)
                        j++;
                    else if(t>target)
                        k--;
                    else if(t==target){
                        List<Integer> l = new ArrayList<>();
                        l.add(nums[start]);
                        l.add(nums[i]);
                        l.add(nums[j++]);
                        l.add(nums[k--]);
                        ans.add(l);
                        
                    }
                }
            }
            return ans;
     }
}

 最后，我的LeetCode做題記錄：https://github.com/Yintianhao/AlgorithmPractice