一【题目类别】

哈希表

二【题目难度】

中等

三【题目编号】

454.四数相加II

四【题目描述】

给你四个整数数组 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 == n u m s 1. l e n g t h$
$n == n u m s 2. l e n g t h$
$n == n u m s 3. l e n g t h$
$n == n u m s 4. l e n g t h$
$1 <= n <= 200$
$2^{28} <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^{28}$

七【解题思路】

将四个数组分为两组
首先遍历第一组的两个数组的所有元素值的可能的组合情况，计算它们的和，其和作为哈希表的key，哈希表的val为同样和的元素组合的次数
然后遍历第二组的两个数组的所有元素值的可能的组合情况，不过我们计算的是相反值（加个负号即可），如果能在哈希表中匹配到值，说明其和为0，那么累加其出现的次数就可以
最后返回结果即可

八【时间频度】

时间复杂度： $O(n^2)$ ， $n$ 为传入的数组的长度
空间复杂度： $O(n^2)$ ， $n$ 为传入的数组的长度

九【代码实现】

Java语言版

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int n = nums1.length;
        int count = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                int sum = nums1[i] + nums2[j];
                if(map.containsKey(sum)){
                    map.put(sum, map.get(sum)+ 1);
                }else{
                    map.put(sum, 1);
                }
            }
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                int oppoSum = -(nums3[i] + nums4[j]);
                if(map.containsKey(oppoSum)){
                    count += map.get(oppoSum);
                }
            }
        }
        return count;
    }
}

C语言版

struct hashTable
{
    int key;
    int val;
    UT_hash_handle hh;
};

int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size)
{
    struct hashTable* map = NULL;
    int count = 0;
    for(int i = 0;i < nums1Size;i++)
    {
        for(int j = 0;j < nums1Size;j++)
        {
            int sum = nums1[i] + nums2[j];
            struct hashTable* temp;
            HASH_FIND_INT(map, &sum, temp);
            if(temp == NULL)
            {
                struct hashTable* insertVal = malloc(sizeof(struct hashTable));
                insertVal->key = sum;
                insertVal->val = 1;
                HASH_ADD_INT(map, key, insertVal);
            }
            else
            {
                temp->val++;
            }
        }
    }
    for(int i = 0;i < nums1Size;i++)
    {
        for(int j = 0;j < nums1Size;j++)
        {
            int oppo_sum = -(nums3[i] + nums4[j]);
            struct hashTable* temp;
            HASH_FIND_INT(map, &oppo_sum, temp);
            if(temp != NULL)
            {
                count += temp->val;
            }
        }
    }
    return count;
}

Python语言版

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        n = len(nums1)
        count = 0
        map = {}
        for a in nums1:
            for b in nums2:
                sum = a + b
                if sum in map:
                    map[sum] = map[sum] + 1
                else:
                    map[sum] = 1
        for c in nums3:
            for d in nums4:
                oppo_sum = -(c + d)
                if oppo_sum in map:
                    count += map[oppo_sum]
        return count

C++语言版

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n = nums1.size();
        int count = 0;
        unordered_map<int, int>  map;
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                int sum = nums1[i] + nums2[j];
                if(map.count(sum) != 0){
                    map[sum]++;
                }else{
                    map[sum] = 1;
                }
            }
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                int oppoSum = -(nums3[i] + nums4[j]);
                if(map.count(oppoSum) != 0){
                    count += map[oppoSum];
                }
            }
        }
        return count;
    }
};