华为OD机试_2025 B卷_静态扫描（Python，100分）（附详细解题思路）
题目描述
静态扫描可以快速识别源代码的缺陷，静态扫描的结果以扫描报告作为输出：
1、文件扫描的成本和文件大小相关，如果文件大小为N，则扫描成本为N个金币
2、扫描报告的缓存成本和文件大小无关，每缓存一个报告需要M个金币
3、扫描报告缓存后，后继再碰到该文件则不需要扫描成本，直接获取缓存结果
给出源代码文件标识序列和文件大小序列，求解采用合理的缓存策略，最少需要的金币数。
输入描述
第一行为缓存一个报告金币数M，L<= M <= 100
第二行为文件标识序列：F1,F2,F3,…,Fn。
第三行为文件大小序列：S1,S2,S3,…,Sn。
备注：
1 <= N <= 10000
1 <= Fi <= 1000
1 <= Si <= 10
输出描述
采用合理的缓存策略，需要的最少金币数
用例
| 输入 | 5 1 2 2 1 2 3 4 1 1 1 1 1 1 1 |
| 输出 | 7 |
| 说明 | 文件大小相同，扫描成本均为1个金币。缓存任意文件均不合算，因而最少成本为7金币。 |
| 输入 | 5 2 2 2 2 2 5 2 2 2 3 3 3 3 3 1 3 3 3 |
| 输出 | 9 |
| 说明 | 无 |
静态扫描成本优化：缓存策略的贪心解法
核心解题思路
题目要求通过合理的缓存策略最小化静态扫描的总成本，核心问题是：对于重复出现的文件，何时缓存报告最划算？ 关键在于权衡扫描成本与缓存成本：
- 扫描成本：每次扫描文件需支付其大小的金币（文件越大成本越高）
- 缓存成本：缓存报告需固定支付M金币（后续相同文件可免扫描）
- 决策关键：对每个文件标识，判断"缓存并复用"还是"每次重新扫描"更经济
贪心策略
对每个文件标识独立决策：
- 若不缓存：总成本 = 文件大小 × 出现次数
- 若缓存：总成本 = 第一次扫描成本 + 缓存成本
- 选择成本更低的方案：
min(文件大小×频次, 文件大小 + M)
为什么贪心有效？每个文件的缓存决策相互独立，缓存一个文件不会影响其他文件的扫描成本。
解题步骤详解
1. 输入处理与参数设置
# 读取缓存成本M
M = int(input().strip())
# 读取文件标识序列
file_ids = list(map(int, input().split()))
# 读取文件大小序列
file_sizes = list(map(int, input().split()))
2. 构建文件分组统计
from collections import defaultdict
# 创建分组字典：记录每个标识的[频次, 总大小, 首次大小]
file_groups = defaultdict(lambda: [0, 0, None])
# 遍历所有文件
for fid, size in zip(file_ids, file_sizes):
# 更新出现频次
file_groups[fid][0] += 1
# 累加总大小（用于不缓存方案）
file_groups[fid][1] += size
# 记录首次出现的大小（用于缓存方案）
if file_groups[fid][2] is None:
file_groups[fid][2] = size
3. 计算最小成本
total_cost = 0
for fid, (count, total_size, first_size) in file_groups.items():
# 不缓存方案：每次扫描
cost_no_cache = total_size
# 缓存方案：首次扫描+缓存
cost_cache = first_size + M
# 选择更经济的方案
total_cost += min(cost_no_cache, cost_cache)
4. 输出结果
print(total_cost)
关键逻辑解析
1. 分组统计的重要性
- 频次(count)：决定重复扫描的成本
- 总大小(total_size)：计算不缓存方案的总成本
- 首次大小(first_size)：缓存方案只需首次扫描成本
为何记录首次大小而非任意大小？
缓存发生在首次扫描时，后续文件无论大小如何都复用结果
2. 成本比较的数学原理
决策依据的数学表达式：
min( Σsᵢ , s₁ + M )
其中：
Σsᵢ：所有出现位置的大小之和s₁：首次出现的大小M：固定缓存成本
3. 独立决策的正确性
- 文件标识相互独立，缓存决策无耦合
- 缓存文件A不影响文件B的扫描
- 局部最优解之和等于全局最优解
完整代码实现
from collections import defaultdict
def main():
# 读取缓存成本
M = int(input().strip())
# 读取文件标识序列
file_ids = list(map(int, input().split()))
# 读取文件大小序列
file_sizes = list(map(int, input().split()))
# 创建分组统计字典
# 格式: {文件标识: [出现次数, 总大小, 首次大小]}
file_groups = defaultdict(lambda: [0, 0, None])
# 遍历所有文件
for fid, size in zip(file_ids, file_sizes):
# 更新出现次数
file_groups[fid][0] += 1
# 累加总大小
file_groups[fid][1] += size
# 记录首次大小
if file_groups[fid][2] is None:
file_groups[fid][2] = size
# 计算最小总成本
total_cost = 0
for fid, (count, total_size, first_size) in file_groups.items():
# 计算两种方案成本
cost_no_cache = total_size
cost_cache = first_size + M
# 选择更经济的方案
total_cost += min(cost_no_cache, cost_cache)
print(total_cost)
if __name__ == "__main__":
main()
复杂度分析
- 时间复杂度：O(N)
- 遍历文件序列：O(N)
- 分组统计：O(N)
- 决策计算：O(K)（K为唯一文件数，K ≤ N）
- 空间复杂度：O(K)
- 存储分组信息：O(K)（K为唯一文件标识数）
示例验证
示例1：
输入：
5
1 2 2 1 2 3 4
1 1 1 1 1 1 1
处理流程：
- 分组统计：
- 文件1: [频次=2, 总大小=2, 首次大小=1]
- 文件2: [频次=3, 总大小=3, 首次大小=1]
- 文件3: [频次=1, 总大小=1, 首次大小=1]
- 文件4: [频次=1, 总大小=1, 首次大小=1]
- 成本决策：
- 文件1: min(2, 1+5)=2
- 文件2: min(3, 1+5)=3
- 文件3: min(1, 1+5)=1
- 文件4: min(1, 1+5)=1
- 总成本：2+3+1+1=7
输出：7
示例2：
输入：
5
2 2 2 2 2 5 2 2 2
3 3 3 3 3 1 3 3 3
处理流程：
- 分组统计：
- 文件2: [频次=8, 总大小=24, 首次大小=3]
- 文件5: [频次=1, 总大小=1, 首次大小=1]
- 成本决策：
- 文件2: min(24, 3+5)=8
- 文件5: min(1, 1+5)=1
- 总成本：8+1=9
输出：9
总结
通过贪心策略解决静态扫描成本优化问题：
- 问题特性：重复文件可复用缓存，决策相互独立
- 核心洞察：缓存的价值 = 后续扫描成本节省 - 缓存成本
- 算法选择：分组统计 + 成本比较（O(N)时间复杂度）
- 优化关键：
- 小文件高频：倾向不缓存（如示例1）
- 大文件高频：倾向缓存（如示例2）
- 低频文件：通常不缓存
实际应用场景：编译器构建系统（如Makefile）、CI/CD流水线，通过缓存中间结果加速重复构建过程。