2025 A卷 100分 题型

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

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

华为OD机试真题《文件目录大小》：

---

题目名称：文件目录大小

---

知识点：字符串、栈操作（DFS）、逻辑处理
时间限制：1秒
空间限制：256MB
限定语言：不限

---

题目描述

一个文件目录的数据格式为：目录id，本目录中文件大小，(子目录id列表)。其中：

• 目录id全局唯一，取值范围为[1, 200]
• 本目录文件大小范围为[1, 1000]
• 子目录id列表个数为[0, 10]

输入描述

• 第一行：两个整数 M 和 N，表示目录个数和待查询的目录id（1 ≤ M ≤ 100，1 ≤ N ≤ 200）。
• 后续 M 行：每行描述一个目录，格式为 目录id 文件大小 (子目录列表)，例如 1 20 (2,3)。

输出描述

• 待查询目录及其所有子目录的文件大小之和。

示例

输入1

3 1  
3 15 ()  
1 20 (2)  
2 10 (3)  

输出1

45  

输入2

4 2  
4 20 ()  
5 30 ()  
2 10 (4,5)  
1 40 ()  

输出2

60  

---

Java

问题分析

这道题目要求计算指定目录及其所有子目录的文件大小总和。我们可以将其视为一个树形结构问题，每个目录作为节点，子目录作为子节点。以下是详细的解决思路和代码实现。

解决思路

1. 输入解析：首先读取目录数目M和目标目录N，然后逐行解析每个目录的信息，包括目录ID、文件大小和子目录列表。
2. 数据结构：使用两个哈希表分别存储目录的大小和子目录列表，便于快速查找。
3. 递归计算：从目标目录开始，递归遍历所有子目录，累加文件大小总和。

代码实现

import java.util.*;

public class Main {
   
    public static void main(String[] args) {
   
        Scanner scanner = new Scanner(System.in);
        // 读取目录个数M和待查询的目录id N
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        scanner.nextLine(); // 跳过剩余换行符

        // 使用哈希表存储目录的大小和子目录列表
        Map<Integer, Integer> sizeMap = new HashMap<>();
        Map<Integer, List<Integer>> childrenMap = new HashMap<>();

        for (int i = 0; i < M; i++) {
   
            String line = scanner.nextLine().trim();
            // 使用正则表达式按一个或多个空格分割行数据
            String[] parts = line.split("\\s+");
            int dirId = Integer.parseInt(parts[0]);
            int size = Integer.parseInt(parts[1]);
            String childrenStr = parts[2]; // 子目录列表部分，如"(2,3)"

            // 处理子目录字符串，提取子目录id
            childrenStr = childrenStr
                    .substring(1, childrenStr.length() - 1) // 去掉括号
                    .trim(); // 去除可能存在的首尾空格
            List<Integer> children = new ArrayList<>();
            if (!childrenStr.isEmpty()) {
    // 处理非空子目录列表
                String[] childIds = childrenStr.split(",");
                for (String childId : childIds) {
   
                    childId = childId.trim(); // 去除每个子目录id的前后空格
                    if (!childId.isEmpty()) {
   
                        children.add(Integer.parseInt(childId));
                    }
                }
            }

            // 将解析后的数据存入哈希表
            sizeMap.put(dirId, size);
            childrenMap.put(dirId, children);
        }

        // 计算目标目录及其所有子目录的总大小
        int totalSize = calculateTotalSize(N, sizeMap, childrenMap);
        System.out.println(totalSize);
    }

    // 递归计算目录总大小
    private static int calculateTotalSize(int dirId, Map<Integer, Integer> sizeMap, Map<Integer, List<Integer>> childrenMap) {
   
        // 获取当前目录的大小
        int sum = sizeMap.get(dirId);
        // 遍历所有子目录，递归累加
        for (int childId : childrenMap.get(dirId)) {
   
            sum += calculateTotalSize(childId, sizeMap, childrenMap);
        }
        return sum;
    }
}

代码详细解析

1. 输入处理：

   • 使用Scanner读取输入，第一行读取M和N。
   • scanner.nextLine()用于跳过换行符，确保后续读取正确。

2. 数据结构初始化：

   • sizeMap存储目录ID到文件大小的映射。
   • childrenMap存储目录ID到子目录列表的映射。

3. 解析目录信息：

   • 每行按空格分割为三部分：目录ID、文件大小、子目录列表字符串。
   • 处理子目录字符串：去除括号和空格，分割后转为整数列表。

4. 递归计算总大小：

   • 递归函数calculateTotalSize从目标目录开始，累加当前目录大小及其所有子目录的总大小。

综合分析

1. 高效的数据结构：哈希表提供O(1)时间复杂度的查找，适合快速访问目录信息。
2. 递归的简洁性：递归自然契合树形结构，代码简洁易懂，适合处理嵌套子目录。
3. 健壮性：正确处理输入中的各种格式（如空格、空子目录列表），确保解析准确。
4. 时间复杂度：每个目录仅访问一次，总时间复杂度为O(M)，满足题目限制。

通过这种方法，能清晰理解目录结构的遍历和递归计算过程，确保正确高效地解决问题。

---

python

题目分析

题目要求计算指定目录及其所有子目录的文件大小总和。每个目录信息以 目录id 文件大小 (子目录列表) 的格式给出，我们需要从输入中解析这些信息，并递归地累加目标目录及其所有子目录的文件大小。

---

解决思路

1. 输入解析：读取目录数量 M 和目标目录 N，解析每个目录的信息。
2. 数据结构：用字典存储目录的文件大小和子目录列表。
3. 递归计算：从目标目录开始，递归遍历所有子目录，累加文件大小总和。

---

Python 代码实现

def main():
    import sys
    # 读取输入
    lines = [line.strip() for line in sys.stdin if line.strip()]
    # 解析 M 和 N
    M, N = map(int, lines[<