力扣第454题：四数相加II

最新推荐文章于 2024-06-22 22:59:06 发布

又在熬

最新推荐文章于 2024-06-22 22:59:06 发布

阅读量1k

点赞数 29

分类专栏：力扣文章标签： leetcode 算法数据结构 python 哈希算法

本文链接：https://blog.csdn.net/weixin_47337647/article/details/137756886

版权

力扣专栏收录该内容

15 篇文章 1 订阅

订阅专栏

题目：

给定四个包含整数的数组列表 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]

输出:

解释:

两个元组如下:

(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

题目解释：

问题要求计算有多少个元组 (i, j, k, l) 满足 A[i] + B[j] + C[k] + D[l] = 0。这里 A, B, C, D 是四个数组列表，包含整数，长度均为 N，其中 0 ≤ N ≤ 500。需要计算有多少个满足条件的 (i, j, k, l) 元组，其中 i, j, k, l 是索引，分别取自数组 A, B, C, D，使得这些数组对应索引位置的元素之和为零。

在解释这个问题的示例时，输入的四个数组列表为：

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

输出为 2，表示有两个元组 (i, j, k, l) 满足 A[i] + B[j] + C[k] + D[l] = 0。

在给定的示例中，有两个满足条件的元组：

(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。

因此，总共有两个满足条件的元组，输出为 2。

这个问题可以通过利用哈希表或字典来计算 A 和 B 的所有可能组合的和，然后计算 C 和 D 的所有可能组合的和。最后，通过寻找相反和的方式来计算满足条件的元组数。

Python3代码解答：

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        # 初始化字典hashmap来存储nums1和nums2中所有可能组合的元素和，以及对应出现的次数
        hashmap = dict()
        # 遍历数组nums1
        for n1 in nums1:
            # 遍历数组nums2
            for n2 in nums2:
                # 通过遍历nums1和nums2所有元素的组合，计算他们的和n1+n2，
                # 如果hashmap中已经存在这个数的和，就将对应的值加1
                if n1 + n2 in hashmap:
                    hashmap[n1+n2] += 1
                    # 如果hashmap中没有这个和，则在字典中创建这个键（两数和），并将值（两数下标）初始化为1
                else:
                    hashmap[n1+n2] = 1

        # 初始化计算器count=0
        count = 0
        # 遍历数组nums3和nums4所有元素的组合
        for n3 in nums3:
            for n4 in nums4:
                # 对于每一对n3和n4,计算它们和的负数
                key = -(n3 + n4)
                # 查找匹配，如果hashmap中存在key,说明可以找到一个组合（i,j）
                # 使得nums[i] + nums[j] 等于key
                if key in hashmap:
                    # key表示的是在hashmap中出现的次数
                    # 当 nums3 中的第一个元素 -1 与 nums4 中的第一个元素 0 组合时，得到 key = -(-1 + 0) = 1；
                    # hashmap[1] 的值是 1，将 hashmap[1] 加到 count 中，这样，count 就增加了 1
                    count += hashmap[key]
        
        # 遍历完nums3和nums4之后，返回count
        return count

代码实现解释：

上述代码实现了一个名为 fourSumCount 的方法，它计算给定四个数组 nums1, nums2, nums3, nums4 的元素的组合数量，使得 (i, j, k, l) 满足 nums1[i] + nums2[j] + nums3[k] + nums4[l] = 0。这里是代码的具体实现过程的解释：

初始化字典：使用字典 hashmap 来存储 nums1 和 nums2 中所有可能组合的元素和，以及对应的出现次数。字典的键是 nums1[i] + nums2[j] 的和，值是这个和在所有组合中出现的次数。
遍历 nums1 和 nums2：代码通过两个嵌套的循环遍历数组 nums1 和 nums2 的所有元素组合。对于每一对 (n1, n2)，计算它们的和 n1 + n2。如果 hashmap 中已经存在这个和，就将对应的值加1，否则在字典中创建这个键，并将值初始化为1。
计算匹配的组合：初始化计数器 count 为 0，用来记录满足条件的组合数量。通过两个嵌套的循环遍历数组 nums3 和 nums4 的所有元素组合。对于每一对 (n3, n4)，计算它们的和的负数 key = -n3 - n4。
查找匹配：检查 hashmap 中是否存在这个 key。如果存在，那么说明可以在 nums1 和 nums2 中找到一个组合 (i, j) 使得 nums1[i] + nums2[j] 等于 key。因此，count 需要增加 hashmap[key]（即 key 在 hashmap 中出现的次数）。
返回结果：遍历 nums3 和 nums4 后，将满足条件的组合数量保存在 count 中，并返回 count。

代码重难点解释：

hashmap[n1 + n2] += 1代码解释：

n1 和 n2 是分别从数组 nums1 和 nums2 中选取的两个数字。
将这两个数字 n1 和 n2 相加，得到 n1 + n2，这代表了一种组合的和。
hashmap[n1 + n2] 这部分代码访问了字典 hashmap 中键为 n1 + n2 的值。
+= 1 表示将这个值加 1。也就是说，如果 hashmap 中已经有这个 n1 + n2 的组合，那么它的次数（值）就会增加 1。

例如，如果 nums1 中有一个元素 n1 = 1，nums2 中有一个元素 n2 = 2，那么它们的和 n1 + n2 = 3。如果 hashmap 中已经存在键 3，那么 hashmap[3] 的值就会增加 1；如果 hashmap 中还没有键 3，那么这行代码会在 hashmap 中创建一个键为 3 的项，并初始化它的值为 1。

`count += hashmap[key]` 代码解释：

key 是一个值，它等于 -n3 - n4，即从 nums3 和 nums4 中选取的两个数字 n3 和 n4 的负和。
hashmap[key] 是从字典 hashmap 中获取键为 key 的值。如果 key 存在于 hashmap 中，那么 hashmap[key] 是 nums1 和 nums2 中组合的和等于 key 的次数。
count += hashmap[key] 表示将 hashmap[key] 的值加到 count 中。这意味着将 nums3 和 nums4 的当前组合 (n3, n4) 对应的负和 key 在 hashmap 中出现的次数加到 count 中。

举例说明：

假设我们有以下四个数组：

nums1 = [1, 2]
nums2 = [-2, -1]
nums3 = [-1, 2]
nums4 = [0, 2]

先来解释 hashmap 的构建过程。我们要遍历 nums1 和 nums2 的所有组合，并计算它们的和，并将这个和存储在字典 hashmap 中。

假设我们首先遍历 nums1 中的第一个元素 1，然后遍历 nums2 中的元素 -2 和 -1，我们得到：

1 + (-2) = -1，这将是一个键（key），并且 hashmap[-1] 的值会增加 1。
1 + (-1) = 0，这将是另一个键，并且 hashmap[0] 的值会增加 1。

然后，我们遍历 nums1 中的第二个元素 2，并继续遍历 nums2 中的元素 -2 和 -1，我们得到：

2 + (-2) = 0，hashmap[0] 的值会再增加 1，因此它的值变成了 2。
2 + (-1) = 1，hashmap[1] 的值会增加 1。

此时 hashmap 中的内容是：

hashmap = {-1: 1, 0: 2, 1: 1}

接下来，我们遍历 nums3 和 nums4 中的所有组合，并寻找 -(nums3[k] + nums4[l]) 在 hashmap 中是否存在。

例如：

当 nums3 中的第一个元素 -1 与 nums4 中的第一个元素 0 组合时，得到 key = -(-1 + 0) = 1。
hashmap[1] 的值是 1，所以我们将 hashmap[1] 加到 count 中。这样，count 就增加了 1。

继续遍历 nums3 中的第一个元素 -1 与 nums4 中的第二个元素 2 时，得到 key = -(-1 + 2) = -1。

hashmap[-1] 的值是 1，所以我们将 hashmap[-1] 加到 count 中。这样，count 又增加了 1。

这个过程继续进行，直到遍历完 nums3 和 nums4 的所有组合，并将 hashmap 中对应 key 的值累加到 count 中。这就是 count += hashmap[key] 的作用：它将 hashmap 中的值（即满足条件的组合的数量）累加到 count 中，计算出总共有多少个 (i, j, k, l) 使得 nums1[i] + nums2[j] + nums3[k] + nums4[l] = 0。