华为od机试-缓存需要最少金币数 /静态扫描(java)

静态扫描可以快速识别源代码的缺陷，静态扫描的结果以扫描报告作为输出:
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
输出描述
采用合理的缓存策略，需要的最少金币数
示例1：
   5
  1 2 2 1 2 3 4
  1 1 1 1 1 1 1
  输出
   7
  说明
文件大小雷同，扫描成本均为1个金币。缓存任意文件均不合算，因而最少成本为7金币。
示例2：
输入
   5
  2 2 2 2 2 5 2 2 2
  3 3 3 3 3 1 3 3 3
  输出
   9
   java代码

1. package odTest;
3. import java.util.Arrays;
4. import java.util.HashMap;
5. import java.util.Map;
6. import java.util.Scanner;
8. public class cacheCoin {
9.         public static void main(String[] args) {
10.                 Scanner scanner = new Scanner(System.in);
11.                 int cacheCost = Integer.parseInt(scanner.nextLine());
12.                 int[] inputFileNos = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
13.                
14.                 int[] FileScanCost = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
15.                
16.                 //key存储文件标识号，int[0]保存扫描价格，int[1]保存同一标识号文件数量
17.                 Map<Integer,int[]> map = new HashMap<>();
18.                 for(int i=0;i<inputFileNos.length;i++) {
19.                         if(map.containsKey(inputFileNos[i])) {
20.                                 int[] info = map.get(inputFileNos[i]);
21.                                 info[1] = info[1]+1;
22. //                                System.out.println(inputFileNos[i]);
23.                                 map.put(inputFileNos[i], info);
24.                         }else {
25.                                 int[] info = new int[2];
26.                             info[0] = FileScanCost[i];
27.                             info[1] = 1;
28.                             map.put(inputFileNos[i], info);
29.                         }
30.                 }
31.                 //最合适的花费
32.                 int optimCost = 0;
33.                 for(Map.Entry<Integer, int[]> entry: map.entrySet()) {
34.                         int[] info = entry.getValue();
35.                         //当缓存的花费小于扫描的花费，则不用扫描
36.                         if( info[0] * info[1] > ( cacheCost + info[0] )) {
37.                                 optimCost = optimCost + cacheCost + info[0];
38.                         }else {//否则用扫描
39.                                 optimCost = optimCost+ info[0] * info[1];
40.                         }
41.                 }
42.                 System.out.println(optimCost);
43.         }
45. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。