华为OD-CPU算力分配

题目描述
现有两组服务器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的算力尽可能小。

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


题目解析
假设A组服务器算力之和为sumA，B组服务器算力之和为sumB，将A组的a和B组的b交换后，A组算力之和等于B组算力之和，则可得公式如下：

sumA - a + b = sumB - b + a

sumA - sumB = 2 * (a - b)

a - b = (sumA - sumB) / 2

其中 sumA, sumB 是已知的，因此，我们可以遍历A组所有元素a，计算出b= a - (sumA - sumB)/2，看B组中是否存在对应b，若存在，则a b就是题解。

JS算法源码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
  // 可能有多组测试数据
  while (true) {
    try {
      const [l1, l2] = (await readline()).split(" ").map(Number);

      const A = (await readline()).split(" ").map(Number);
      const B = (await readline()).split(" ").map(Number);

      let sumA = 0;
      for (let a of A) {
        sumA += a;
      }

      let sumB = 0;
      const setB = new Set();

      for (let b of B) {
        sumB += b;
        setB.add(b);
      }

      // 由于本题必然存在解，因此sumA-sumB的结果肯定可以整除2，如果不能整除则half_diff为小数，
      // 而half_diff = a - b，其中a,b都是整数，因此不可能存在half_diff是小数的情况
      const half_diff = (sumA - sumB) / 2;

      // 记录用于交换的最小的a
      let minA = Infinity;
      // 记录题解
      let ans = "";

      for (let a of A) {
        const b = a - half_diff;

        if (setB.has(b)) {
          if (a < minA) {
            minA = a;
            ans = `${a} ${b}`;
          }
        }
      }

      console.log(ans);
    } catch (e) {
      break;
    }
  }
})();

Java算法源码

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

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

    // 可能有多组测试数据
    while (sc.hasNext()) {
      int l1 = sc.nextInt();
      int l2 = sc.nextInt();

      int sumA = 0;
      int[] A = new int[l1];
      for (int i = 0; i < l1; i++) {
        int a = sc.nextInt();
        sumA += a;
        A[i] = a;
      }

      int sumB = 0;
      HashSet<Integer> setB = new HashSet<>();
      for (int i = 0; i < l2; i++) {
        int b = sc.nextInt();
        sumB += b;
        setB.add(b);
      }

      // 由于本题必然存在解，因此sumA-sumB的结果肯定可以整除2，如果不能整除则half_diff为小数，
      // 而half_diff = a - b，其中a,b都是整数，因此不可能存在half_diff是小数的情况
      int half_diff = (sumA - sumB) / 2;

      // 记录用于交换的最小的a
      int minA = Integer.MAX_VALUE;
      String ans = "";

      for (int a : A) {
        int b = a - half_diff;

        if (setB.contains(b)) {
          if (a < minA) {
            minA = a;
            ans = a + " " + b;
          }
        }
      }

      System.out.println(ans);
    }
  }
}

Python算法源码

import sys

while True:
    try:
        l1, l2 = map(int, input().split())
        A = list(map(int, input().split()))
        B = list(map(int, input().split()))
    
        sumA = sum(A)
    
        sumB = 0
        setB = set()
    
        for b in B:
            sumB += b
            setB.add(b)
    
        # 由于本题必然存在解，因此sumA-sumB的结果肯定可以整除2，如果不能整除则half_diff为小数，
        # 而half_diff = a - b，其中a,b都是整数，因此不可能存在half_diff是小数的情况
        half_diff = (sumA - sumB) // 2
    
        # 记录用于交换的最小的a
        minA = sys.maxsize
        # 记录题解
        ans = ""
    
        for a in A:
            b = a - half_diff
    
            if b in setB:
                if a < minA:
                    minA = a
                    ans = f"{a} {b}"
    
        print(ans)
    except:
        break

C算法源码

#include <stdio.h>
#include <limits.h>
#include <string.h>

#define MAX_SIZE 10000
#define MAX_VALUE 100000

int main() {
    // 可能有多组测试数据
    while(1) {
        int l1, l2;
        int res = scanf("%d %d", &l1, &l2);
        if(res != 2) {
            break;
        }

        int A[MAX_SIZE];
        int A_size = 0;

        int sumA = 0;

        while (scanf("%d", &A[A_size])) {
            sumA += A[A_size];
            A_size++;
            if(getchar() != ' ') break;
        }

        int B[MAX_SIZE];
        int B_size = 0;

        int sumB = 0;
        int setB[MAX_VALUE + 1] = {0};

        while (scanf("%d", &B[B_size])) {
            sumB += B[B_size];
            setB[B[B_size]] = 1;
            B_size++;
            if(getchar() != ' ') break;
        }

        // 由于本题必然存在解，因此sumA-sumB的结果肯定可以整除2，如果不能整除则half_diff为小数，
        // 而half_diff = a - b，其中a,b都是整数，因此不可能存在half_diff是小数的情况
        int half_diff = (sumA - sumB) / 2;

        int minA = INT_MAX;
        char ans[15];

        for(int i=0; i<A_size; i++) {
            int a = A[i];
            int b = a - half_diff;
            if(b > 0 && setB[b] && a < minA) {
                minA = a;
                char tmp[15];
                sprintf(tmp, "%d %d", a, b);
                strcpy(ans, tmp);
            }
        }

        puts(ans);
    }

    return 0;
}

想要全套206到题 请加微信