京东笔试编程题：采购单+保卫方案

Posted 2020-08-07 kimi9py

采购单
时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
过年啦！小B高兴的不行了，她收到了很多红包，可以实现好多的愿望呢。小B可是对商店货架上心仪的货物红眼好久了，只因囊中羞涩作罢，这次她可是要大大的shopping一番。小B想去购物时，总是习惯性的把要买的东西列在一个购买清单上，每个物品单独列一行（即便要买多个某种物品），这次也不例外。
小B早早的来到了商店，由于她太激动，以至于她到达商店的时候，服务员还没有把各个商品的价签排好，所有的价签还都在柜台上。因此还需要一段时间，等服务器把价签放到对应的商品处，小B才能弄清她的购买清单所需的费用。
小B都有些迫不及待了，她希望你能够根据购买清单，帮她算算最好和最坏的情况下所需的费用，你能帮她吗？
输入
输入中有多组测试数据。每组测试数据的第一行为两个整数n和m（1=<n, m=<1000），分别表示价签的数量以及小B的购买清单中所列的物品数。第二行为空格分隔的n个正整数，表示货架上各类物品的价格，每个数的大小不超过100000。随后的m行为购买清单中物品的名称，所有物品名称为非空的不超过32个拉丁字母构成的字符串，保证清单中不同的物品种类数不超过n，且商店有小B想要购买的所有物品。

输出
对每组测试数据，在单独的行中输出两个数a和b，表示购买清单上所有的物品可能需要的最小和最大费用。

样例输入
5 3
4 2 1 10 5
apple
orange
mango
6 5
3 5 1 6 8 1
peach
grapefruit
banana
orange
orange
样例输出
7 19
11 30

 1 import java.util.*;
 2 public class Main {
 3     public static void main(String aegs[]) {
 4         Scanner sc = new Scanner(System.in);
 5         int n, m;
 6         int[] val = new int[1001];
 7         while (sc.hasNext()) {
 8             n = sc.nextInt();
 9             m = sc.nextInt();
10             for (int i = 0; i < n; ++i) {
11                 val[i] = sc.nextInt();
12             }
13             Map<String, Integer> mp = new <String, Integer>HashMap();
14             String name;
15             for (int i = 0; i < m; ++i) {
16                 name = sc.next();
17                 int num = mp.getOrDefault(name, 0) + 1;
18                 mp.put(name, num);
19             }
20             Arrays.sort(val, 0, n);
21             List<Integer> list = new ArrayList<Integer>(mp.values());
22             int size = list.size();
23             Integer[] array = (Integer[])list.toArray(new Integer[size]);
24             Arrays.sort(array);
25             int max = 0, min = 0;
26             int i = 0;
27             for (Integer num : array) {
28                 max += val[n - size + i] * num;
29                 if (size - 1 - i >= 0) {
30                     min += num * val[size - 1 - i];
31                 }
32                 i++;
33             }
34             System.out.println(min + " " + max);
35         }
36     }
37 }

 

保卫方案
时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
战争游戏的至关重要环节就要到来了，这次的结果将决定王国的生死存亡，小B负责首都的防卫工作。首都处于一个四面环山的盆地中，周围的n个小山构成一个环，作为预警措施，小B计划在每个小山上设置一个观察哨，日夜不停的瞭望周围发生的情况。
一旦发生外敌入侵事件，山顶上的岗哨将点燃烽烟。若两个岗哨所在的山峰之间没有更高的山峰遮挡且两者之间有相连通路，则岗哨可以观察到另一个山峰上的烽烟是否点燃。由于小山处于环上，任意两个小山之间存在两个不同的连接通路。满足上述不遮挡的条件下，一座山峰上岗哨点燃的烽烟至少可以通过一条通路被另一端观察到。对于任意相邻的岗哨，一端的岗哨一定可以发现一端点燃的烽烟。
小B设计的这种保卫方案的一个重要特性是能够观测到对方烽烟的岗哨对的数量，她希望你能够帮她解决这个问题。
输入
输入中有多组测试数据。每组测试数据的第一行为一个整数n（3<=n <=10^6），为首都周围的小山数量，第二行为n个整数，依次表示小山的高度h，（1<=h<=10^9）。
输出
对每组测试数据，在单独的一行中输出能相互观察到的岗哨的对数。

样例输入
5
1 2 4 5 3
样例输出
7

 1 /**
 2  * Created by Administrator on 2016/9/5.
 3  */
 4 
 5 import java.util.Scanner;
 6 
 7 public class Main{
 8     public static void main(String[] args){
 9         Scanner in =new Scanner(System.in);
10         while(in.hasNext()){
11             int n=in.nextInt();
12             int[] arr=new int[n];
13             for(int i=0;i<n;i++){
14                 arr[i]=in.nextInt();
15             }
16             System.out.println(getCount(arr));
17         }
18     }
19 
20 
21 public static int getCount(int[] arr) {
22         if (arr == null || arr.length < 2) {
23             return 0;
24         } else {
25             int res = 0;
26         int[][] dp = getDP(arr);
27         for (int i = 0; i < dp.length; i++) {
28             for (int j = 0; j < dp.length; j++) {
29                 res += dp[i][j];
30             }
31         }
32         return res / 2;
33         }
34 }
35 
36     public static int[][] getDP(int[] arr) {
37         int[][] dp = new int[arr.length][arr.length];
38         dp[0][arr.length - 1] = 1;  //头尾是相邻的，配对
39         dp[arr.length - 1][0] = 1;
40         for (int i = 0; i < dp.length; i++) {
41             for (int j = 0; j < dp.length; j++) {
42                 if(dp[i][j] == 0){
43                     if(i == j){
44                         dp[i][j] = 0;   //自己跟自己不配对
45                     }else if (i == j - 1 || j == i - 1) {
46                         dp[i][j] = 1;   //相邻的配对
47                     } else {
48                         //如果dp[i][j-1]为1，则arr[j-1]满足arr[j - 1] <= Math.min(arr[i], arr[j])使arr[i]、arr[j]配对
49                         if (j > 0 && dp[i][j - 1] == 1
50                         && arr[j - 1] <= Math.min(arr[i], arr[j])) {
51                             dp[i][j] = 1;
52                         }
53                         //如果dp[i-1][j]为1，则arr[i-1]满足arr[i - 1] <= Math.min(arr[i], arr[j])使arr[i]、arr[j]配对
54                         if (i > 0 && dp[i - 1][j] == 1
55                          && arr[i - 1] <= Math.min(arr[i], arr[j])) {
56                             dp[i][j] = 1;
57                         }
58                     }
59                 }
60             }
61         }
62         return dp;
63     }
64 }