算法学习day06:两数之和，四数相加II，三数之和，四数之和（Java）

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路：使用循环遍历，每遍历一个数，判断之前是否出现过符合目标的值（如遍历到7，判断之前是否出现过target-7），因此我们需要用个东西去存储遍历过的数据及其下标

像这样，要处理成对数据的时候，就到了map集合出场，以键值对的方式存储数据和下标。所以我们尝试用键存储数据，值存储下标
代码如下：

    public static int[] solution(int[] arr, int target){
        HashMap<Integer, Integer> data = new HashMap<>();
        int temp = 0;//存储找到的目标数据下标
        int[] res = new int[2];
        for (int i = 0; i < arr.length; i++) {
            if(data.containsKey(target - arr[i])){
                temp = data.get(target - arr[i]);
                res[0] = temp;
                res[1] = i;
                return res;
            }else {
                data.put(arr[i], i);
            }
        }
        return null;
    }

总结：当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

四数相加II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:
输入:

A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:

2

解释:

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

这道题如果用暴力解法，时间复杂度是O(n^4)，我们尝试缩小一点。
先对A和B数组进行相加，把相加的全部结果放到一个集合里面去，再把C和D相加的结果放到集合内，这样从计算四个数字相加就变成了两个，稍微缩小了时间复杂度（但是空间的占用多了一些）

再思考，如果A数组是[1,2]，B数组是[2,1]，会导致A[0]+B[0]和A[1]+B[1]相等的情况，但都算有效的元组，所以不能用set集合（set集合会自动去重），在这种既要记录数据，又要记录数据的出现次数的时候，可以使用map集合了，数据作为键，出现次数作为值

至于为什么不好用数组：两个数组相加最多有500*500个结果，这么大的数组比较占用位置，不采纳

注意，如果两个新数组内有匹配的数字（相加为0）的话，有效的元组应该是两个数字对应出现次数相乘

代码如下：

    public static int solution(int[] A, int[] B, int[] C, int[] D){
        HashMap<Integer,Integer> map1 = new HashMap<>();
        int temp;//记录两数之和
        int res = 0;//记录返回的结果
        for (int i : A) {
            for (int j : B) {
                temp = i + j;
                if (map1.containsKey(temp)) {
                    map1.put(temp, map1.get(temp) + 1);
                } else {
                    map1.put(temp, 1);
                }
            }
        }
        for (int i : C) {
            for (int j : D) {
                temp = i + j;
                if (map1.containsKey(-temp)) {
                    res += map1.get(-temp);
                }
            }
        }

        return res;
    }

三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0，请你找出所有满足条件且不重复的三元组。

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

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

这道题用哈希法来做比较麻烦，建议使用双指针。

做题之前，要先对数组进行排序，从小到大排序，然后使用for循环和左右指针，一个在i后面，一个在数组最后面。让i和左右指针对应的数字相加，如果结果大于0，就让右指针向左移，如果结果小于0，就让左指针向右移，如果实在无法达成等于0（左指针= 右指针）那么就让i++

思路不难，重点在于去重，如数组[-1,-1,-2,3]中，只能得到一个集合：[-1,-2,3]
因此，需要设置一个限制条件：如果nums[i] == nums[i-1]则进行跳过，不能用nums[i] == nums[i+1]，原因见数组[-1,-1,-2]，如果使用后者的判断方式，i直接到了第二个-1处，双指针就无法达成目标。

代码如下：

public static List solution(int[] nums){
    List list = new ArrayList();//外部集合

    Arrays.sort(nums);
    int left;
    int right;
    int sum;
    for (int i = 0; i < nums.length; i++) {
        if(i >0 && nums[i] == nums[i-1]){
            continue;
        }else if(nums[i] > 0){
            return list;//最小的i也大于0，说明之后的数据都无法使三数之和为0
        }
        left = i + 1;
        right = nums.length - 1;
        while (left < right){
            sum  = nums[i] + nums[left] + nums[right];
            if(sum > 0){
                right--;
            }else if(sum < 0){
                left++;
            }else {
                list.add(Arrays.asList(nums[i], nums[left], nums[right]));
            }
        }
    }
    return list;
}

四数之和

题意：给定一个包含 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] ]

这道题和三数之和大部分一致，只是外部要再多套一个循环，这样就变成了：两个确定的量，两个指针

不同的是，这里的target不是一定等于0的，也可能是负数，就会导致一个问题：

数组nums = [-4,-1,0,0]，target = -5是没有问题的
之前认为最小的数字 >0 说明无法凑出三元组，但这里的四元组两个负数相加可能会变成更小的负数

所以，在判断结束的基础上（num[i]>target），还要补上一句target>0，如果连最小的num[i]都大于正数target的话，说明之后不会再出现四数相加为0的情况了

代码如下：

    public static List solution(int[] nums, int target){
        List list = new ArrayList();
        Arrays.sort(nums);
        int left;
        int right;
        long sum;//以防int类型溢出，使用long类型存储结果
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if(nums[i]>target && target > 0){//此后均为正数相加，且最小的nums[i]也大于target
                    return list;
                }
                if(i>0 && nums[i] == nums[i-1]){//去重操作
                    continue;
                }
                left = j + 1;
                right = nums.length - 1;
                while(left < right){
                    sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if( sum > 0){
                        right--;
                    }else if(sum < 0){
                        left++;
                    }else {
                        list.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                    }
                }
            }
        }
        return list;
    }

今日学习时长：2h