代码随想录刷题-哈希表-四数相加II

四数相加II

本节对应代码随想录中：代码随想录，讲解视频：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

习题

题目链接：454. 四数相加 II - 力扣（LeetCode）

给你四个整数数组 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

暴力解法

暴力解法会超时，这里只作为参考

题目意思简单来说就是四个数组分别找出一个数，让它们相加为0。最直接的就是四个 for 循环遍历每个数组，只要和为0，那就加1。但是四重 for 循环的时间复杂度是 O(n^4)，肯定会超时。

那我们可不可以把四重 for 循环降到三重 for 循环？

我们这章学的是哈希表，而哈希表查找指定元素是否出现过的时间复杂度为 O(1)。第四层 for 循环实际上就是查找有没有0-nums1-nums2-nums3的数存在，存在的话，它的次数是多少。那我们就可以使用一个 unordered_map 来存放一个数组如 nums4，key 存放 nums4的元素，value 存放其出现次数。这样就可以把时间复杂度降到 O(n^3)，不过即使优化到三重 for 循环但还是会超时

注意不能用 set，set 只能存放 key，即不能统计出现次数。虽然用 multiset 然后再用 count 函数计数也能统计次数，但是 multiset 的查找时间复杂度为 O(logn)。

class Solution {
   public:
    int fourSumCount(vector<int>& nums1,vector<int>& nums2,vector<int>& nums3,vector<int>& nums4) {
        int size = nums1.size();
        int res = 0;
        unordered_map<int, int> hash_map;
        // key存放nums4的元素,value存放出现的次数
        for (int i = 0; i < size; i++) {
            hash_map[nums4[i]]++;
        }
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                for (int m = 0; m < size; m++) {
                    // 如果能在hash_map中找到-(nums1+nums2+nums3),则将res+出现的次数
                    auto it = hash_map.find(0 - nums1[i] - nums2[j] - nums3[m]);
                    if (it != hash_map.end()) {
                        res += it->second;
                    }
                }
            }
        }
        return res;
    }
};

• 时间复杂度：O(n^3)。其中 n 为 nums1, nums2, nums3, nums4 数组的长度，因为有三个嵌套的 for 循环
• 空间复杂度：O(n)。因为使用了一个哈希表来存储 nums4 的元素及其出现次数，而哈希表的大小最多为 n

哈希表

既然上面的三重 for 循环会超时，那解法一定是小于三重 for 循环的。比如，可不可以只使用两重 for 循环即 O(n^2)

上面的解法中，我们是用 map 存放一个数组的元素，然后遍历剩下的三个数组。那如果我们先遍历两个数组，让 map 存放的是它们的和，然后再遍历另外两个数组。就可以查找 map 中是否含有-(nums3+nums4)，有的话加上它的次数即可。这样我们就可以继续优化到 O(n^2)。

同理，如果是六个数组，那就可以存放三个数组的和，再三重 for 循环，即存放一半数组的和

class Solution {
   public:
   int fourSumCount(vector<int>& nums1,vector<int>& nums2,vector<int>& nums3,vector<int>& nums4) {
        int size = nums1.size();
        int res = 0;
        unordered_map<int, int> hash_map;
        // key存放nums1+nums2的和,value存放和出现的次数
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                hash_map[nums1[i] + nums2[j]]++;
            }
        }
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                // 如果能在hash_map中找到-(nums3+nums4),则将res+出现的次数
                auto it = hash_map.find(0 - nums3[i] - nums4[j]);
                if (it != hash_map.end()) {
                    res += it->second;
                }
            }
        }
        return res;
    }
};

• 时间复杂度：O(n^2)。n 为 nums1、nums2、nums3、nums4 数组的长度，因为使用了两层 for 循环遍历四个数组，其中每一次操作都花费 O(1) 的时间。并且还有一次对哈希表的查找操作，查找的时间复杂度为 O(1)，所以总时间复杂度为 O(n^2)
• 空间复杂度：O(n^2)。n 为 nums1、nums2、nums3、nums4 数组的长度，我们使用一个哈希表记录 nums1 和 nums2 中所有元素的两两之和，最多有 n^2 种不同的可能性，所以空间复杂度为 O(n^2)