【华为OD】机试真题 - CPU算力分配 - 2024年D卷

题目描述
现有两组服务器A和B，每组有多个算力不同的CPU，其中 A[i] 是 A 组第 i 个CPU的运算能力，B[i] 是 B组 第 i 个CPU的运算能力。
一组服务器的总算力是各CPU的算力之和。
为了让两组服务器的算力相等，允许从每组各选出一个CPU进行一次交换，
求两组服务器中，用于交换的CPU的算力，并且要求从A组服务器中选出的CPU，算力尽可能小。
输入描述
第一行输入为L1和L2，以空格分隔，L1表示A组服务器中的CPU数量，L2表示B组服务器中的CPU数量。
第二行输入为A组服务器中各个CPU的算力值，以空格分隔。
第三行输入为B组服务器中各个CPU的算力值，以空格分隔。

• 1 ≤ L1 ≤ 10000
• 1 ≤ L2 ≤ 10000
• 1 ≤ A[i] ≤ 100000
• 1 ≤ B[i] ≤ 100000

输出描述
对于每组测试数据，输出两个整数，以空格分隔，依次表示A组选出的CPU算力，B组选出的CPU算力。
要求从A组选出的CPU的算力尽可能小。
备注

• 保证两组服务器的初始总算力不同。
• 答案肯定存在

示例1：

输入：
	2 2
	1 1
	2 2
输出：
	1 2
说明：从A组中选出算力为1的CPU，与B组中算力为2的进行交换，使两组服务器的算力都等于3。

示例2：

输入：
	2 2
	1 2
	2 3
输出：
	1 2

示例3：

输入：
	1 2
	2
	1 3
输出：
	2 3

示例4：

输入：
	3 2
	1 2 5
	2 4
输出：
	5 4

解题思路：题目较长，但仔细阅读后，发现就是考察数组。

---

Python 解法：

# CPU算力分配
def find_exchange_cpus(L1, L2, A, B):
    sumA = sum(A)
    sumB = sum(B)
    diff = (sumA - sumB) // 2

    B_set = set(B)

    for a in sorted(A):
        b = a - diff
        if b in B_set:
            return a, b

    return -1, -1  # 如果没有找到合适的交换对


if __name__ == "__main__":
    # data = input().split()
    # L1 = int(data[0])
    # L2 = int(data[1])
    # A = list(map(int, data[2:2 + L1]))
    # B = list(map(int, data[2 + L1:2 + L1 + L2]))
    A, B = map(int, input().split())
    cpuA = list(map(int, input().split()))
    cpuB = list(map(int, input().split()))

    out_a, out_b = find_exchange_cpus(A, B, cpuA, cpuB)
    print(out_a, out_b)

Java 解法：

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class ServerCPUExchange {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int L1 = scanner.nextInt();
        int L2 = scanner.nextInt();

        int[] A = new int[L1];
        int[] B = new int[L2];

        for (int i = 0; i < L1; i++) {
            A[i] = scanner.nextInt();
        }

        for (int i = 0; i < L2; i++) {
            B[i] = scanner.nextInt();
        }

        scanner.close();

        int[] result = findExchangeCPUs(L1, L2, A, B);
        System.out.println(result[0] + " " + result[1]);
    }

    private static int[] findExchangeCPUs(int L1, int L2, int[] A, int[] B) {
        int sumA = 0;
        int sumB = 0;

        for (int a : A) {
            sumA += a;
        }

        for (int b : B) {
            sumB += b;
        }

        int diff = (sumA - sumB) / 2;

        Set<Integer> BSet = new HashSet<>();
        for (int b : B) {
            BSet.add(b);
        }

        for (int a : A) {
            int b = a - diff;
            if (BSet.contains(b)) {
                return new int[] {a, b};
            }
        }
        return new int[] {-1, -1};  // 如果没有找到合适的交换对
    }
}

C++ 解法：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

pair<int, int> findExchangeCPUs(int L1, int L2, const vector<int>& A, const vector<int>& B) {
    int sumA = accumulate(A.begin(), A.end(), 0);
    int sumB = accumulate(B.begin(), B.end(), 0);
    int diff = (sumA - sumB) / 2;

    unordered_set<int> BSet(B.begin(), B.end());

    for (int a : A) {
        int b = a - diff;
        if (BSet.find(b) != BSet.end()) {
            return {a, b};
        }
    }
    return {-1, -1};  // 如果没有找到合适的交换对
}

int main() {
    int L1, L2;
    cin >> L1 >> L2;

    vector<int> A(L1);
    vector<int> B(L2);

    for (int i = 0; i < L1; ++i) {
        cin >> A[i];
    }

    for (int i = 0; i < L2; ++i) {
        cin >> B[i];
    }

    pair<int, int> result = findExchangeCPUs(L1, L2, A, B);
    cout << result.first << " " << result.second << endl;

    return 0;
}

+++================================================+++
以上内容仅为个人学习记录使用。
如有转载，请附有原文出处链接。

牛客网原题链接：https://www.nowcoder.com/issue/tutorial?zhuanlanId=jvZvZj&uuid=c8e8ef7781814e50a8f4198796e10e93