LeetCode 1512题解析：哈希表在数组统计中的应用

1. 问题背景与题目解析

今天我们来拆解一道经典的LeetCode数组题目——1512. Number of Good Pairs（好数对的数目）。这道题在周赛和日常练习中出现的频率相当高，也是理解数组基本操作和哈希表应用的绝佳案例。

题目描述很简单：给定一个整数数组nums，返回"好数对"的数量。好数对的定义是满足nums[i] == nums[j]且i < j的数对(i,j)。换句话说，就是统计数组中所有相等元素的下标组合，且前一个下标必须小于后一个下标。

举个例子：

• 输入：[1,2,3,1,1,3]
• 输出：4
  解释：有4个好数对，分别是(0,3), (0,4), (2,5), (3,4)

这道题在LeetCode上被标记为"简单"，但实际面试中经常作为热身题出现。我见过不少候选人一开始觉得简单，但在处理边界条件和优化时间复杂度时却频频出错。下面我们就从暴力解法开始，逐步优化到最优解。

2. 暴力解法与时间复杂度分析

最直观的解法就是双重循环暴力枚举所有可能的数对：

python复制def numIdenticalPairs(nums):
    count = 0
    n = len(nums)
    for i in range(n):
        for j in range(i+1, n):
            if nums[i] == nums[j]:
                count += 1
    return count

这个解法的时间复杂度是O(n²)，空间复杂度是O(1)。对于小规模数据（n≤100）完全够用，但当n达到10⁴量级时就会超时。

注意：在面试中即使给出暴力解法，也要明确指出它的复杂度缺陷，并说明你会考虑优化。这展示了你的问题分析能力。

3. 哈希表优化解法

观察到好数对的数量实际上与相同数字的出现频率相关。具体来说，如果一个数字出现k次，那么它贡献的好数对数量就是组合数C(k,2)=k*(k-1)/2。

基于这个数学原理，我们可以使用哈希表（字典）来统计每个数字的出现频率：

python复制def numIdenticalPairs(nums):
    from collections import defaultdict
    freq = defaultdict(int)
    count = 0
    for num in nums:
        count += freq[num]  # 当前数字之前出现的次数
        freq[num] += 1      # 更新频率
    return count

这个算法只需要一次遍历：

1. 初始化一个空字典记录数字频率
2. 遍历数组，对于每个数字：
   • 该数字之前出现的次数就是它能形成的新好数对数量
   • 更新该数字的出现频率
3. 最后返回累计的count

时间复杂度降为O(n)，空间复杂度O(n)（最坏情况下需要存储所有不同数字）。

4. 算法正确性验证

让我们用之前的例子验证这个算法：
输入：[1,2,3,1,1,3]

遍历过程：

• 1: count=0, freq=
• 2: count=0, freq=
• 3: count=0, freq=
• 1: count+=1=1, freq=
• 1: count+=2=3, freq=
• 3: count+=1=4, freq=

最终输出4，与暴力解法一致，验证了算法的正确性。

5. 不同语言实现对比

这道题在不同编程语言中的实现有些微差异，主要体现在哈希表的使用上：

Java实现：

java复制public int numIdenticalPairs(int[] nums) {
    int[] freq = new int[101]; // 题目说明数字范围1-100
    int count = 0;
    for (int num : nums) {
        count += freq[num]++;
    }
    return count;
}

C++实现：

cpp复制int numIdenticalPairs(vector<int>& nums) {
    unordered_map<int, int> freq;
    int count = 0;
    for (int num : nums) {
        count += freq[num]++;
    }
    return count;
}

JavaScript实现：

javascript复制var numIdenticalPairs = function(nums) {
    const freq = {};
    let count = 0;
    for (const num of nums) {
        count += freq[num] || 0;
        freq[num] = (freq[num] || 0) + 1;
    }
    return count;
};

提示：在Python中，使用defaultdict比普通dict更简洁；而在Java中，由于题目限制了数字范围，直接用数组比HashMap更高效。

6. 边界条件与测试用例

好的代码必须考虑各种边界情况。针对这道题，我们需要测试：

1. 最小输入：空数组或单元素数组

   • [] → 0
   • [5] → 0

2. 无重复元素：

   • [1,2,3] → 0

3. 全部相同元素：

   • [7,7,7] → 3 (C(3,2)=3)

4. 最大规模测试（性能验证）：

   • 10^4个相同数字 → 49995000

5. 混合情况：

   • [1,1,2,2,2,3] → 4 (C(2,2)+C(3,2)=1+3=4)

在面试中，主动提出这些测试用例能展现你的全面思考。实际编码时也应该先写几个测试用例再开始实现。

7. 复杂度分析与优化空间

我们已经将时间复杂度从O(n²)优化到O(n)，这是理论上的最优解。但在实际应用中还可以考虑：

1. 如果数字范围已知且较小（如本题限定1-100），用数组代替哈希表可以略微提升速度。

2. 并行计算：对于极大数组，可以将数组分块，分别统计各部分频率后合并结果。不过对于面试题通常不需要。

3. 内存优化：如果数字范围很大但重复率高，可以考虑更紧凑的数据结构。

不过这些优化在实际面试中通常不是必须的，除非面试官特别要求。

8. 相似题目与扩展思考

理解这道题的核心思路后，可以解决一系列类似问题：

1. LeetCode 1. Two Sum：同样需要记录数字出现信息
2. LeetCode 217. Contains Duplicate：简化版的好数对问题
3. LeetCode 219. Contains Duplicate II：增加了下标距离限制
4. 统计三元组(i,j,k)满足nums[i]==nums[j]==nums[k]且i<j<k：扩展思路相同

这类问题的共同特点是需要统计元素出现频率或位置关系，哈希表往往是关键。掌握这个模式可以举一反三解决许多数组相关问题。

9. 实际应用场景

虽然看似简单，这类算法在实际中有广泛应用：

1. 推荐系统：统计用户行为模式的共现频率
2. 生物信息学：DNA序列中特定模式的配对统计
3. 质量控制：检测生产线上相同缺陷模式的重复出现
4. 社交网络分析：共同好友或兴趣的匹配统计

理解算法背后的数学原理（组合计数）比记住代码更重要，这能帮助你在真实场景中灵活应用。

10. 常见错误与调试技巧

新手在解决这个问题时常犯的错误包括：

1. 双重循环下标错误：内层循环应该从i+1开始，而非0
2. 哈希表未初始化：直接访问不存在的key导致异常
3. 组合数计算错误：误用排列公式而非组合公式
4. 整数溢出：对于极大n，C(n,2)可能超出int范围

调试时可以：

• 打印中间变量（如每次循环后的count和freq）
• 用小规模测试用例手动验证
• 对比暴力解法和优化解法的结果

11. 代码风格与最佳实践

写出可维护的代码同样重要：

1. 变量命名：使用有意义的名称如freq而非map
2. 注释：解释算法的关键步骤
3. 函数拆分：如果逻辑复杂，将统计和计算分离
4. 异常处理：检查输入是否为空等边缘情况

例如更工程化的实现：

python复制def count_good_pairs(nums):
    """统计好数对数量
    
    Args:
        nums: 整数数组
        
    Returns:
        好数对的数量
    """
    if not nums:
        return 0
        
    freq = {}
    pair_count = 0
    
    for num in nums:
        pair_count += freq.get(num, 0)
        freq[num] = freq.get(num, 0) + 1
    
    return pair_count

12. 不同解法性能实测

为了直观展示优化效果，我在LeetCode上测试了不同规模数据下的运行时间：

可以看到，哈希表解法在大数据量下的优势非常明显。这也验证了时间复杂度分析的实际意义。

13. 数学原理深入

这道题的核心数学原理其实是组合数学中的组合计数：

对于每个出现k次的数字，它贡献的好数对数量是C(k,2)=k(k-1)/2。因此整个问题的解可以表示为：

result = Σ C(freq[num], 2) for all num in nums

理解这一点后，我们可以推导出哈希表解法的正确性：在遍历时，当前数字之前出现的m次，正好能与当前数字形成m个新数对，因此累加这m次。

14. 面试技巧与回答策略

如果在面试中被问到这道题，建议采取以下策略：

1. 先明确问题：复述题目要求，确认理解正确
2. 提出暴力解法：说明思路和时间复杂度
3. 分析优化空间：指出重复计算的部分
4. 提出哈希表解法：解释数学原理
5. 讨论复杂度：时间和空间复杂度
6. 测试用例：主动提出边缘情况
7. 代码实现：写出清晰代码
8. 后续问题：准备回答可能的扩展问题

这样的结构化回答能展现你系统化解决问题的能力。

15. 个人实战经验分享

在多次解决这个问题后，我总结了一些实用技巧：

1. 预处理检查：先看题目约束，数字范围1-100意味着可以用数组替代哈希表优化
2. 变量复用：像freq[num]++这样的表达式可以同时完成取值和更新
3. 早期终止：如果题目允许，发现某个数字频率超过一定值可以直接计算返回
4. 空间权衡：有时用排序+双指针可以O(1)空间，但时间复杂度会变为O(nlogn)

在实际编码比赛中，我通常会先写暴力解法确保理解正确，再逐步优化。对于Python选手，熟练使用collections.defaultdict和Counter能大幅提升编码速度。