【华为OD-E卷 - 最优资源分配 100分（python、java、c++、js、c）】

题目

某块业务芯片最小容量单位为1.25G，总容量为M*1.25G，对该芯片资源编号为1，2，…，M。该芯片支持3种不同的配置，分别为A、B、C。
配置A：占用容量为 1.25 * 1 = 1.25G 配置B：占用容量为 1.25 * 2 = 2.5G 配置C：占用容量为 1.25 * 8 = 10G 某块板卡上集成了N块上述芯片，对芯片编号为1，2，…，N，各个芯片之间彼此独立，不能跨芯片占用资源。给定板卡上芯片数量N、每块芯片容量M、用户按次序配置后，请输出芯片资源占用情况，保证消耗的芯片数量最少。
资源分配规则：按照芯片编号从小到大分配所需资源，芯片上资源如果被占用标记为1，没有被占用标记为0.
用户配置序列：用户配置是按次序依次配置到芯片中，如果用户配置序列种某个配置超过了芯片总容量，丢弃该配置，继续遍历用户后续配置

输入描述

M：每块芯片容量为 M * 1.25G，取值范围为：1~256

N：每块板卡包含芯片数量，取值范围为1~32

用户配置序列：例如ACABA，长度不超过1000

输出描述

板卡上每块芯片的占用情况

备注

用户配置是按次序依次配置到芯片中，如果用户配置序列种某个配置超过了芯片总容量，丢弃该配置，继续遍历用户后续配置

用例

用例一：

输入：

8
2
ACABA

输出：

11111000
11111111

用例二：

输入：

8
2
ACBCB

输出：

11111000
11111111

python解法

解题思路：
这个问题的目标是将一系列配置（由字符表示）分配到多个芯片上，每个芯片有一个固定的初始容量，然后根据配置所需的单位数，依次为芯片分配资源。分配完后，输出每个芯片的剩余状态，用“1”表示已分配的资源，用“0”表示剩余的资源。

输入参数解析：

m 是每个芯片的初始容量。
n 是芯片的数量。
configs 是一个字符串，包含了多个配置，配置是字符（‘A’, ‘B’, ‘C’）组成的，每个字符代表不同的资源需求。
资源分配：

先建立一个与芯片数量 n 相同大小的列表 chips，每个元素初始化为 m，代表每个芯片的剩余资源。
使用 config_map 字典，将每种配置字符映射到其对应的资源需求值：‘A’ 对应 1 单位，‘B’ 对应 2 单位，‘C’ 对应 8 单位。
遍历每个配置字符，在 chips 列表中找到第一个可以满足该资源需求的芯片，将资源从该芯片上减去。如果找到合适的芯片，则跳出当前配置的循环，处理下一个配置。
在所有配置分配完后，输出每个芯片的状态。已分配的资源用“1”表示，剩余的资源用“0”表示。
输出格式：

每个芯片的状态通过字符串输出，字符串的长度为 m，有 m - chip 个“1”，其余为“0”，表示已分配的资源和剩余的资源

def allocate_resources(m, n, configs):# 初始化每个芯片的资源量，假设每个芯片的初始容量是 mchips = [m] * n# 定义一个字典，映射配置字符到需要的资源单位config_map = {'A': 1, 'B': 2, 'C': 8}# 遍历配置字符串，逐一处理每个配置for config in configs:required_units = config_map[config]  # 获取当前配置需要的资源单位数for i in range(n):if chips[i] >= required_units:  # 如果当前芯片资源足够chips[i] -= required_units  # 从该芯片扣除所需资源break  # 分配完资源后跳出当前配置的循环，处理下一个配置# 输出每个芯片的资源分配情况for chip in chips:used_units = m - chip  # 已经使用的资源单位数# 输出芯片的资源状态，已使用部分为 "1"，剩余部分为 "0"print("1" * used_units + "0" * chip)# 主程序入口，获取输入并调用函数
if __name__ == "__main__":m = int(input())  # 读取每个芯片的初始容量n = int(input())  # 读取芯片的数量configs = input()  # 读取配置字符串allocate_resources(m, n, configs)  # 调用资源分配函数

java解法

解题思路
这个问题的目标是模拟资源分配的过程，给定一组芯片，每个芯片有 m 个单元（可以是 0 或 1，0 表示未分配资源，1 表示已分配资源），并根据提供的配置字符串（‘A’、‘B’、‘C’）依次为芯片分配资源。资源分配的规则如下：

‘A’ 需要 1 单元资源。
‘B’ 需要 2 单元资源。
‘C’ 需要 8 单元资源。
每个配置字符会尽量从空闲的芯片上分配资源。如果一个芯片有足够的空闲单元，它会被占用，直到该配置的资源分配完成。

代码逻辑：
输入解析：

m 表示每个芯片的资源单元数。
n 表示芯片的数量。
sequence 是一个字符串，每个字符代表需要多少资源单位（‘A’ 为 1，‘B’ 为 2，‘C’ 为 8）。
分配资源：

使用一个大数组 chips 来表示所有芯片的资源状态。数组的长度为 n * m，每个元素代表一个资源单元，初始值为 0（表示该资源单元空闲）。
遍历 sequence 中的每个配置，分配资源。每次分配资源时，遍历 chips 数组中的资源单元，直到该配置所需的资源分配完毕。
输出结果：

输出每个芯片的资源分配情况。每个芯片对应一行，输出该芯片的每个资源单元的状态（0 表示未分配，1 表示已分配）。

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);// 输入每个芯片的资源单元数 m 和芯片的数量 nint m = input.nextInt(); int n = input.nextInt();// 输入资源配置序列String sequence = input.next();// 调用资源分配函数allocateResources(m, n, sequence);}public static void allocateResources(int m, int n, String sequence) {// 创建一个数组 chips，用来表示所有芯片的资源分配情况// 数组的长度是 n * m，表示所有芯片的所有资源单元int[] chips = new int[n * m]; // 初始化所有单元为 0（表示未分配）// 初始化资源索引int index = 0;// 遍历资源配置序列，逐个分配资源for (char config : sequence.toCharArray()) {int needed = 0;// 根据配置字符确定所需资源数量if (config == 'A') needed = 1;else if (config == 'B') needed = 2;else if (config == 'C') needed = 8;// 从空闲资源单元开始分配，直到配置所需资源分配完while (index < chips.length && needed > 0) {int chipIndex = index % m; // 计算当前是哪个芯片的第几个资源单元if (chips[index] == 0) { // 如果该单元未分配资源chips[index] = 1; // 分配该资源单元needed--; // 减少剩余需要的资源单位数}index++; // 移动到下一个资源单元}}// 输出每个芯片的资源使用情况for (int i = 0; i < n; i++) {// 输出当前芯片的所有资源单元的分配情况for (int j = 0; j < m; j++) {System.out.print(chips[i * m + j]); // 输出每个单元的状态}System.out.println(); // 换行，表示一个芯片的输出结束}}
}

C++解法

解题思路
这个问题的目标是根据给定的资源配置序列，在多个芯片上分配资源，并输出每个芯片的资源使用情况。每个芯片有 m 个资源单元，资源配置序列中的字符（‘A’、‘B’、‘C’）分别代表不同的资源需求，且每个字符对应的资源需求数是不同的：

‘A’ 需要 1 单元资源。
‘B’ 需要 2 单元资源。
‘C’ 需要 8 单元资源。
每个芯片的资源单元数为 m，且每个单元的资源量是固定的，实际分配资源时将资源需求乘以 1.25 来模拟资源的消耗。资源分配过程尽量从空闲芯片中分配资源，直到资源配置所需的全部资源被分配完。

代码逻辑：
初始化阶段：

boardCard 数组表示 n 个芯片，每个芯片的初始资源容量为 m * 1.25（因为资源单元数与 m 的关系是 m * 1.25）。
dict 数组定义了配置字符对应的资源需求，其中 dict[0] 对应 ‘A’ 需要 1 单元资源，dict[1] 对应 ‘B’ 需要 2 单元资源，dict[2] 对应 ‘C’ 需要 8 单元资源。
资源分配：

遍历配置字符串 sequence 中的每个配置（‘A’、‘B’、‘C’），根据配置的需求，计算所需的资源量 need。
遍历所有芯片，找到第一个资源足够的芯片，将资源从该芯片中分配出去。资源分配完成后跳出当前配置的循环，处理下一个配置。
输出结果：

输出每个芯片的资源状态。如果芯片资源被分配了，就输出 “1”，如果未分配，则输出 “0”。每个芯片输出一行，每个芯片的资源状态由若干 “1” 和 “0” 组成

#include <iostream>
#include <vector>
#include <string>using namespace std;// 获取分配结果的函数
void getResult(int m, int n, const string& sequence) {// boardCard 数组表示所有芯片的资源，初始化为每个芯片 m * 1.25vector<double> boardCard(n, m * 1.25);// dict 数组记录不同配置所需的资源单位：'A' 对应 1，'B' 对应 2，'C' 对应 8int dict[3] = { 1, 2, 8 };// 遍历配置序列，依次为芯片分配资源for (char config : sequence) {// 计算当前配置所需的资源数量，乘以 1.25 来模拟每个单元的资源量double need = 1.25 * dict[config - 'A']; // 根据 'A'、'B'、'C' 计算需要的资源量// 遍历所有芯片，寻找第一个能够分配足够资源的芯片for (int j = 0; j < n; j++) {if (boardCard[j] >= need) {  // 如果当前芯片有足够的资源boardCard[j] -= need;    // 从该芯片分配资源break;                   // 分配完后跳出当前配置的循环，处理下一个配置}}}// 输出每个芯片的资源使用情况for (int i = 0; i < n; i++) {// 计算当前芯片未使用的资源单元数，除以 1.25 来得到原始单元数int unUsed = static_cast<int>(boardCard[i] / 1.25);// 计算已使用的资源单元数int used = m - unUsed;// 输出当前芯片的已使用资源单元，输出 1for (int j = 0; j < used; j++) {cout << "1";}// 输出当前芯片的未使用资源单元，输出 0for (int j = 0; j < unUsed; j++) {cout << "0";}cout << endl;  // 换行，输出一个芯片的资源使用状态}
}// 主函数入口
int main() {int m, n;  // m 是每个芯片的资源单元数，n 是芯片的数量string sequence;  // 配置序列，包含需要分配的资源配置// 读取输入cin >> m >> n;cin >> sequence;// 调用 getResult 函数，获取并输出资源分配结果getResult(m, n, sequence);return 0;
}

C解法

解题思路
该问题要求模拟资源的分配，给定多个芯片，每个芯片有 m 个资源单元，并且每个单元可以按需分配资源。每个资源配置字符（‘A’、‘B’、‘C’）需要不同的资源单元。根据配置序列依次为芯片分配资源。分配完成后，我们需要输出每个芯片的资源使用情况。

资源配置：

每个芯片有 m 个资源单元。
配置字符：
‘A’ 需要 1 单元资源。
‘B’ 需要 2 单元资源。
‘C’ 需要 8 单元资源。
每个资源单元的容量是 1.25（用浮点数表示）。因此，每个芯片的初始资源容量是 m * 1.25。
资源分配：

每个配置字符按照资源需求顺序依次处理。对于每个配置，查找第一个有足够资源的芯片并分配资源。如果找到了合适的芯片，就为该芯片分配所需的资源。
输出：

输出每个芯片的资源使用情况：已分配的资源用 “1” 表示，未分配的资源用 “0” 表示。
每个芯片输出一行。
代码逻辑：
输入：

输入每个芯片的资源单元数 m 和芯片的数量 n。
输入一个字符串 sequence，该字符串包含了配置序列。
资源分配：

初始化一个 boardCard 数组，表示每个芯片的资源容量。每个芯片的初始容量为 m * 1.25。
遍历配置序列 sequence，根据配置要求从芯片中找到资源足够的芯片，进行资源分配。
输出每个芯片的使用情况：

根据分配后的 boardCard 数组，计算每个芯片的已用和未用资源，输出对应的资源使用情况。

#include <stdio.h>
#include <string.h>#define MAX_CHIPS 32           // 定义最大芯片数量
#define MAX_CONFIG 1000        // 定义配置序列最大长度// 计算资源分配结果并输出
void getResult(int m, int n, char sequence[]) {double boardCard[MAX_CHIPS];  // 用数组表示所有芯片的容量，初始化为每个芯片 m * 1.25// 初始化每个芯片的资源容量为 m * 1.25for (int i = 0; i < n; i++) {boardCard[i] = m * 1.25;}// 创建一个字典，映射配置 'A', 'B', 'C' 到相应的资源需求int dict[3] = { 1, 2, 8 };  // A -> 1, B -> 2, C -> 8// 遍历配置序列，逐一分配资源for (int i = 0; i < strlen(sequence); i++) {char config = sequence[i];// 根据配置字符计算需要的资源量，乘以 1.25 以匹配资源容量double need = 1.25 * dict[config - 'A'];  // 'A' -> 1, 'B' -> 2, 'C' -> 8// 寻找第一个能够满足资源需求的芯片进行分配for (int j = 0; j < n; j++) {// 如果当前芯片的资源大于等于需求，则分配资源if (boardCard[j] >= need) {boardCard[j] -= need;  // 从该芯片分配资源break;  // 资源分配后跳出循环，处理下一个配置}}}// 输出每个芯片的资源使用情况for (int i = 0; i < n; i++) {// 计算当前芯片未使用的资源单元数int unUsed = (int)(boardCard[i] / 1.25);  // 通过将剩余容量除以 1.25 来得到未使用的块数// 计算已使用的资源单元数int used = m - unUsed;  // 已使用的资源单元数// 输出已使用的资源单元，输出 "1"for (int j = 0; j < used; j++) {printf("1");}// 输出未使用的资源单元，输出 "0"for (int j = 0; j < unUsed; j++) {printf("0");}printf("\n");  // 输出完每个芯片后换行}
}// 主程序入口
int main() {int m, n;  // m 为每个芯片的资源单元数，n 为芯片的数量char sequence[MAX_CONFIG];  // 存储配置序列// 输入每个芯片的资源单元数 m 和芯片数量 nscanf("%d %d", &m, &n);// 输入配置序列scanf("%s", sequence);// 调用资源分配函数getResult(m, n, sequence);return 0;  // 程序结束
}

JS解法

解题思路
该问题的目标是模拟资源分配的过程，根据输入的配置序列，依次为多个板（或芯片）分配资源。每个板（或芯片）有固定的容量，且每个配置（A、B、C）需要不同的资源量。分配完成后，我们需要输出每个板的资源使用情况。

输入说明：

第一个输入是每个板的容量 capacity，表示每个板有 capacity 个资源单元。
第二个输入是板的数量 boards，表示有多少个板参与资源分配。
第三个输入是配置序列 cards，它包含了需要分配的资源配置。每个字符代表一种资源配置：
‘A’ 需要 1.25 单位资源。
‘B’ 需要 2.5 单位资源。
‘C’ 需要 10 单位资源。
资源分配的步骤：

初始化一个数组 boardStates，每个板的初始容量为 capacity * 1.25，表示每个板的资源总量。
遍历 cards 配置序列，对于每个配置，查找第一个能够满足资源需求的板（即剩余资源大于等于需求的板），为其分配资源。
资源分配完成后，更新该板的剩余资源，并继续处理下一个配置。
输出结果：

对每个板的资源情况进行输出，输出每个板的使用情况：已分配资源的部分用 “1” 表示，未分配的部分用 “0” 表示。每个板的资源状态单独占一行

const readline = require("readline");  // 引入 readline 模块，用于处理输入
const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});const data = [];  // 存储输入的三行数据
rl.on("line", (line) => {data.push(line);  // 将每行输入数据存入 data 数组if (data.length === 3) {  // 当收到 3 行输入数据后，开始处理const capacity = parseInt(data[0], 10);  // 第1行：每个板的容量const boards = parseInt(data[1], 10);    // 第2行：板的数量const cards = data[2];                    // 第3行：配置序列（A、B、C）// 调用资源分配函数allocateBoards(capacity, boards, cards);data.length = 0;  // 清空数据，准备处理下一个输入}
});// 分配资源的函数
function allocateBoards(capacity, boards, cards) {// 初始化每个板的剩余容量，容量为 capacity * 1.25let boardStates = Array(boards).fill(capacity * 1.25);// 配置与资源需求的映射const cardValues = { A: 1.25, B: 2.5, C: 10 };// 遍历配置序列，依次为每个板分配资源for (const card of cards) {const cardNeed = cardValues[card];  // 获取当前配置所需的资源量for (let i = 0; i < boards; i++) {  // 遍历所有板if (boardStates[i] >= cardNeed) {  // 如果当前板有足够的资源boardStates[i] -= cardNeed;  // 为该板分配资源break;  // 分配完成后跳出循环，处理下一个配置}}}// 输出每个板的资源使用情况boardStates.forEach((remaining) => {// 计算未使用的资源单元数，空闲资源 = 剩余资源 / 1.25const emptySlots = Math.floor(remaining / 1.25);// 计算已使用的资源单元数const filledSlots = capacity - emptySlots;// 输出已使用资源的部分（1），未使用的部分（0）console.log("1".repeat(filledSlots) + "0".repeat(emptySlots));});
}