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

id="article_content" class="article_content clearfix" style="height: 2000px; overflow: hidden;"> id="content_views" class="markdown_views prism-tomorrow-night">

【华为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
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
  • 3
输出：
11111000
11111111
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
用例二：
输入：
8
2
ACBCB
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
  • 3
输出：
11111000
11111111
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

python解法

输入参数解析：

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):
    # 初始化每个芯片的资源量，假设每个芯片的初始容量是 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)  # 调用资源分配函数

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

java解法

‘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 和芯片的数量 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(); // 换行，表示一个芯片的输出结束
        }
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

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 
#include 
#include 

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;
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

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 
#include 

#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;  // 程序结束
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

JS解法

输入说明：

第一个输入是每个板的容量 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.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));
    });
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

注意：

如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏

注：本文转载自blog.csdn.net的CodeClimb的文章"https://blog.csdn.net/CodeClimb/article/details/144918304"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！