华为OD刷题C卷 - 每日刷题37（CPU算力分配，API集群负载统计）

1、（CPU算力分配）：

这段代码是解决“CPU算力分配”的问题。它提供了一个Java类Main，其中包含main方法和swap方法，用于找出两组服务器中用于交换的CPU的算力，使得两组服务器的总算力相等，并要求从A组服务器中选出的CPU算力尽可能小。

main方法首先读取A组和B组服务器中CPU的数量，然后读取每组服务器中各个CPU的算力值。接着，调用swap方法并打印需要交换的CPU算力。

swap方法首先计算两组服务器的总算力，然后找出需要交换的CPU算力的差值target。接着，对A组服务器的CPU算力进行升序排序，并通过遍历和查找来找出满足条件的最小CPU算力。最后，返回A组和B组中用于交换的CPU算力。

2、（API集群负载统计）：

这段代码是解决“API集群负载统计”的问题。它提供了一个Java类Main，其中包含main方法，用于统计RESTful API集合中各个API的访问频次。

main方法首先读取访问历史日志的条数n，然后读取每个API的URL地址，并将其分割成层级存储在二维数组api中。接着，读取要查询的层级index和关键字key，并通过遍历访问历史日志来统计关键字在指定层级上出现的频次。最后，打印出统计结果。

package OD369;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @description CPU算力分配
 * @level 6
 * @score 100
 */

/**
 * 题目描述
 * 现有两组服务器A和B，每组有多个算力不同的CPU，其中 A[i] 是 A 组第 i 个CPU的运算能力，B[i] 是 B组 第 i 个CPU的运算能力。
 * <p>
 * 一组服务器的总算力是各CPU的算力之和。
 * <p>
 * 为了让两组服务器的算力相等，允许从每组各选出一个CPU进行一次交换，
 * <p>
 * 求两组服务器中，用于交换的CPU的算力，并且要求从A组服务器中选出的CPU，算力尽可能小。
 * <p>
 * 输入描述
 * 第一行输入为L1和L2，以空格分隔，L1表示A组服务器中的CPU数量，L2表示B组服务器中的CPU数量。
 * <p>
 * 第二行输入为A组服务器中各个CPU的算力值，以空格分隔。
 * <p>
 * 第三行输入为B组服务器中各个CPU的算力值，以空格分隔。
 * <p>
 * 1 ≤ L1 ≤ 10000
 * 1 ≤ L2 ≤ 10000
 * 1 ≤ A[i] ≤ 100000
 * 1 ≤ B[i] ≤ 100000
 * 输出描述
 * 对于每组测试数据，输出两个整数，以空格分隔，依次表示A组选出的CPU算力，B组选出的CPU算力。
 * <p>
 * 要求从A组选出的CPU的算力尽可能小。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //两组服务器分别的CPU数量
        int n1 = sc.nextInt();
        int n2 = sc.nextInt();
        //服务器A的CPU算力
        int[] a = new int[n1];
        for (int i = 0; i < n1; i++) {
            a[i] = sc.nextInt();
        }
        //服务器B的CPU算力
        int[] b = new int[n2];
        for (int i = 0; i < n2; i++) {
            b[i] = sc.nextInt();
        }
        System.out.println(swap(a, b));
    }

    //交换两个数组中的一个值，使两数组和相等，要求从a中取的数要尽量小
    public static String swap(int[] arrA, int[] arrB) {
        int sumA = sum(arrA);
        int sumB = sum(arrB);
        //因为答案肯定存在，所以一定能被2整除
        int target = (sumA - sumB) / 2;

        //交换的值尽可能小
        //int min = Integer.MAX_VALUE;

        //把A升序排序，从头遍历，找到的第一个可交换的就一定是最小的
        Arrays.sort(arrA);


        //记录题解
        String ans = "";

        //sumA - a + b = sumB -b + a
        // a-b = (sumA-sumB) / 2
        //即 a-b = target
        for (int a : arrA) {
            int temp = a - target;
            //如果arrB中存在temp，因为A是升序排序，则当前a，b就是最优解
            for (int b : arrB) {
                if (b == temp) {
                    return a + " " + b;
                }
            }
        }
        //输入保证答案肯定存在
        return ans;

    }

    //求数组和
    public static int sum(int[] a) {
        int ans = 0;
        for (int i : a) {
            ans += i;
        }
        return ans;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

package OD370;

import java.util.Scanner;

/**
 * @description API集群负载统计
 * @level 3
 */

/**
 * 题目描述
 * 某个产品的RESTful API集合部署在服务器集群的多个节点上，近期对客户端访问日志进行了采集，需要统计各个API的访问频次，根据热点信息在服务器节点之间做负载均衡，现在需要实现热点信息统计查询功能。
 * <p>
 * RESTful API是由多个层级构成，层级之间使用 / 连接，如 /A/B/C/D 这个地址，A属于第一级，B属于第二级，C属于第三级，D属于第四级。
 * <p>
 * 现在负载均衡模块需要知道给定层级上某个名字出现的频次，未出现过用0表示，实现这个功能。
 * <p>
 * 输入描述
 * 第一行为N，表示访问历史日志的条数，0 ＜ N ≤ 100。
 * <p>
 * 接下来N行，每一行为一个RESTful API的URL地址，约束地址中仅包含英文字母和连接符 / ，最大层级为10，每层级字符串最大长度为10。
 * <p>
 * 最后一行为层级L和要查询的关键字。
 * <p>
 * 输出描述
 * 输出给定层级上，关键字出现的频次，使用完全匹配方式（大小写敏感）。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //访问日志的条数
        int n = Integer.parseInt(sc.nextLine());
        //最大层级为10
        String[][] api = new String[n][10];
        for (int i = 0; i < n; i++) {
            //注意 开头有"/"的话，拆分出来第一个元素为"",下标为0
            api[i] = sc.nextLine().split("/");
        }
        String[] search = sc.nextLine().split(" ");
        int index = Integer.parseInt(search[0]);
        String key = search[1];
        int count = 0;
        for (int i = 0; i < n; i++) {
            //防止index下标越界
            if (index < api[i].length) {
                if (api[i][index].equals(key)) {
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54