【华为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"，表示已分配的资源和剩余的资源
python
def allocate_resources(m, n, configs):
# 初始化每个芯片的资源量，假设每个芯片的初始容量是 m
chips = [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 表示已分配）。
java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 输入每个芯片的资源单元数 m 和芯片的数量 n
int 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" 组成
cpp
#include <iostream>
#include <vector>
#include <string>
using namespace std;
// 获取分配结果的函数
void getResult(int m, int n, const string& sequence) {
// boardCard 数组表示所有芯片的资源，初始化为每个芯片 m * 1.25
vector<double> boardCard(n, m * 1.25);
// dict 数组记录不同配置所需的资源单位：'A' 对应 1，'B' 对应 2，'C' 对应 8
int 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;
// 输出当前芯片的已使用资源单元，输出 1
for (int j = 0; j < used; j++) {
cout << "1";
}
// 输出当前芯片的未使用资源单元，输出 0
for (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 数组，计算每个芯片的已用和未用资源，输出对应的资源使用情况。
c
#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.25
for (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 和芯片数量 n
scanf("%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" 表示。每个板的资源状态单独占一行
javascript
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.25
let 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.25
const emptySlots = Math.floor(remaining / 1.25);
// 计算已使用的资源单元数
const filledSlots = capacity - emptySlots;
// 输出已使用资源的部分（1），未使用的部分（0）
console.log("1".repeat(filledSlots) + "0".repeat(emptySlots));
});
}注意：
如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏