从零学算法454

454.给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例 2：
输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1
提示：
n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28

• 最无脑的我们会想到直接四重循环，在此基础上我们用哈希表降低时间复杂度，key 为和，value 为组合数，记录 num1 和 nums2 的所有和的情况，然后双重循环 nums3 以及 nums4，当他们的和与 map 中某个 key 相加为 0 就加上此时的组合数。比如当遍历 nums3 以及 nums4 时某个和为 2，我们就去找 map 中记录了和为 -2 的可能性有几种。
• 即将 A[i]+B[j]+C[k]+D[l]=0 转化为 A[i]+B[j]=-(C[k]+D[l])

•   public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        Map<Integer,Integer> map = new HashMap<>();
        for(int i:nums1){
            for(int j:nums2){
                map.put(i+j, map.getOrDefault(i+j,0)+1);
            }
        }
        for(int i:nums3){
            for(int j:nums4){
                res += map.getOrDefault(0-i-j,0);
            }
        }
        return res;
    }
  

• 也可以用数组模拟哈希表，用数组下标表示两数相加的和，但两数相加可能为负，所以比如和的范围为 [-100,100] 我们就创建长度为 100 - (-100) + 1 的数组，下标 0-100 存放和为 [-100,0] 的组合数，下标 101-200 存放和为 [1,100] 的组合数，这里的原理就是让所有和都减去最小值 -100，那么最小的和就为 0，就能对应数组下标最小值 0，即和的范围从 [-100,100] 看做 [0,200]。

•   public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int[] max_min_1 = getMaxMin(nums1);
        int[] max_min_2 = getMaxMin(nums2);
        int[] max_min_3 = getMaxMin(nums3);
        int[] max_min_4 = getMaxMin(nums4);
        // 因为我们是把 num1+num2 看做和为正数的一组
        // 把 num3+num4 看做和为负数的一组
        // 所以对负数组来说最大值是 -(min3+min4)，因为负数越小，加上负号后越大
        // 比如 -100 < -1，100 > 1
        int max = Math.max(max_min_1[0] + max_min_2[0], -(max_min_3[1] + max_min_4[1]));
        // 最小值同理，负数相加和越大，加上负号后，值反而越小
        // 比如 -1 > -100，1 < 100
        int min = Math.min(max_min_1[1] + max_min_2[1], -(max_min_3[0] + max_min_4[0]));
        int[] hash = new int[max - min + 1];
        int res = 0;
        for(int i:nums1){
            for(int j:nums2){
                hash[i+j-min]++;
            }
        }
        for(int i:nums3){
            for(int j:nums4){
                res += hash[-i-j-min];
            }
        }
        return res;
    }
    public int[] getMaxMin(int[] nums) {//返回数组的最大和最小值
        int min = nums[0], max = nums[0];
        for (int num: nums) {
            if (num < min) min = num;
            else if (num > max) max = num;
        }
        return new int[] {max, min};
    }
  

• 甚至可以手写哈希表调节效率和内存，不过这就不赘述了