题目描述

静态扫描可以快速识别源代码的缺陷，静态扫描的结果以扫描报告作为输出：

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 defaultdictdef 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 = 0for fid, (count, total_size, first_size) in file_groups.items():# 计算两种方案成本cost_no_cache = total_sizecost_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