华为OD机试真题——统计匹配的二元组个数（2025A卷：100分）Java/python/JavaScript/C++/C语言/GO六种最佳实现

2025 A卷 100分 题型

本文涵盖详细的问题分析、解题思路、代码实现、代码详解、测试用例以及综合分析；
并提供Java、python、JavaScript、C++、C语言、GO六种语言的最佳实现方式！

2025华为OD真题目录+全流程解析/备考攻略/经验分享

华为OD机试真题《统计匹配的二元组个数》：

---

---

题目名称：统计匹配的二元组个数

---

知识点：数组、哈希表
时间限制：1秒
空间限制：32MB
限定语言：不限

---

题目描述

给定两个数组A和B，统计满足A[i] == B[j]的二元组(i,j)的总个数。

输入描述

• 第一行输入数组A的长度M
• 第二行输入数组B的长度N
• 第三行输入数组A的元素（空格分隔）
• 第四行输入数组B的元素（空格分隔）

输出描述
输出匹配的二元组个数。若不存在匹配，输出0。

示例1
输入：

5  
4  
1 2 3 4 5  
4 3 2 1  

输出：

4  

示例2
输入：

6  
3  
1 2 4 4 2 1  
1 2 3  

输出：

4  

---

Java

问题分析

我们需要统计两个数组A和B中满足A[i] == B[j]的二元组(i,j)的总个数。直接遍历所有可能的组合会导致时间复杂度为O(M*N)，但通过哈希表优化可以将时间复杂度降低到O(M + N)。

---

解题思路

1. 哈希表统计频率：遍历数组A，用哈希表记录每个元素出现的次数。
2. 遍历数组B匹配：遍历数组B，对于每个元素，在哈希表中查找其出现次数并累加。

---

代码实现

import java.util.*;
import java.io.*;

public class Main {
   
    public static void main(String[] args) throws IOException {
   
        // 使用BufferedReader读取输入，避免Scanner的换行符问题
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        // 读取数组A和B的长度
        int M = Integer.parseInt(br.readLine());
        int N = Integer.parseInt(br.readLine());
        
        // 读取数组A的元素并转换为整型数组
        String[] aParts = br.readLine().split(" ");
        int[] a = new int[M];
        for (int i = 0; i < M; i++) {
   
            a[i] = Integer.parseInt(aParts[i]);
        }
        
        // 读取数组B的元素并转换为整型数组
        String[] bParts = br.readLine().split(" ");
        int[] b = new int[N];
        for (int i = 0; i < N; i++) {
   
            b[i] = Integer.parseInt(bParts[i]);
        }
        
        // 创建哈希表统计数组A中每个元素的出现次数
        Map<Integer, Integer> countMap = new HashMap<>();
        for (int num : a) {
   
            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
        }
        
        // 遍历数组B，累加匹配次数
        int result = 0;
        for (int num : b) {
   
            result += countMap.getOrDefault(num, 0);
        }
        
        // 输出结果
        System.out.println(result);
    }
}

---

代码详细解析

1. 读取输入：

   • BufferedReader逐行读取输入，避免Scanner的换行符问题。
   • 前两行读取数组A和B的长度M和N。
   • 第三行读取数组A的元素并转换为整型数组。
   • 第四行读取数组B的元素并转换为整型数组。

2. 统计数组A的元素频率：

   • 使用HashMap存储数组A中每个元素及其出现次数。
   • countMap.getOrDefault(num, 0)确保元素不存在时返回0。

3. 遍历数组B计算匹配次数：

   • 对数组B中的每个元素，查找其在哈希表中的出现次数。
   • 累加所有匹配次数，得到最终结果。

---

示例测试

示例1输入：

5
4
1 2 3 4 5
4 3 2 1

输出：

4

解析：

• 数组A中每个元素出现1次，数组B中的元素4、3、2、1均能在A中找到，总共有4对。

示例2输入：

6
3
1 2 4 4 2 1
1 2 3

输出：

4

解析：

• 数组A中1出现2次、2出现2次，数组B中的1和2分别匹配2次，总共有4次。

---

综合分析

1. 时间复杂度：

   • 统计频率：O(M)，遍历数组A一次。
   • 匹配计算：O(N)，遍历数组B一次。
   • 总复杂度：O(M + N)，线性时间复杂度。

2. 空间复杂度：

   • 哈希表存储：O(M)，存储数组A中所有不同元素及其频率。

3. 优势：

   • 高效性：相比暴力法的O(M*N)，哈希表将复杂度优化到O(M + N)。
   • 代码简洁：逻辑清晰，易于理解和维护。

4. 适用场景：

   • 处理大规模数据时，哈希表方法能显著提升性能。
   • 适用于需要快速查找元素出现次数的场景。

---

python

问题分析

我们需要统计两个数组A和B中满足A[i] == B[j]的二元组(i,j)的总个数。直接遍历所有可能的组合会导致时间复杂度为O(M*N)，但通过哈希表优化可以将时间复杂度降低到O(M + N)。

---

解题思路

1. 哈希表统计频率：遍历数组A，用字典记录每个元素出现的次数。
2. 遍历数组B匹配：遍历数组B，对于每个元素，在字典中查找其出现次数并累加。

---

代码实现

def main():
    import sys
    # 读取输入数据
    m = int(sys.stdin.readline())       # 读取数组A的长度
    n = int(sys.stdin.readline())       # 读取数组B的长度
    
    # 读取数组A的元素并转换为整数列表
    a = list(map(int, sys.stdin.readline().split()))
    # 验证数组长度是否匹配输入值
    if len(a) != m:
        print(0)
        return
    
    # 读取数组B的元素并转换为整数列表
    b = list(map(int, sys.stdin.readline().split()))
    # 验证数组长度是否匹配输入值
    if len(b) != n:
        print(0)
        return
    
    # 创建字典统计数组A中每个元素的出现次数
    count_dict = {
   }
    for num in a:
        # 如果元素存在，计数+1；不存在则初始化为0后+1
        count_dict[num] = count_dict.get(num,