当前位置：首页 > article >正文

华为OD机试-最优资源分配-2022Q4 A卷-Py/Java/JS

article 2025/2/6 2:52:16

某块业务芯片最小容量单位为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

输出描述
板卡上每块芯片的占用情况

备注
用户配置是按次序依次配置到芯片中，如果用户配置序列种某个配置超过了芯片总容量，丢弃该配置，继续遍历用户后续配置。
示例1：输入输出示例仅供调试，后台判题数据一般不包含示例

输入
8
2
ACABA
输出

11111000

11111111

示例2：输入输出示例仅供调试，后台判题数据一般不包含示例

输入
8
2
ACBCB
输出

11111000

11111111

Java 代码

import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
 
public class Main { 
    public static void main(String[] args) {
        //处理输入
        Scanner in=new Scanner(System.in); 
        int M = in.nextInt();
        int N = in.nextInt();
        String user_input = in.next();
 
        // 表示各个芯片的剩余总容量
        double[] used = new double[N];
        for (int i=0;i<N;i++) {
            used[i] = M*1.25;
        }
 
        // 按照用户配置分配每一个容量
        for(int i=0; i<user_input.length();i++) {
            double capacity = 0.0;
            if (user_input.charAt(i) == 'A') {
                capacity = 1.25;
            } else if (user_input.charAt(i) == 'B') {
                capacity = 2.5;
            } else {
                capacity = 10;
            }
 
            // 从第一块芯片开始分配
            for (int j=0;j<N;j++) {
                if (used[j] >= capacity) {
                    used[j] -= capacity;
                    break;
                }
            }
        }
 
        //输出
        for (int j=0;j<N;j++) {
            String output_str="";
            
            for (int k=0;k<M-used[j]/1.25;k++) {
                output_str += '1';
            }
            for (int i=0;i<used[j]/1.25;i++) {
                output_str += "0";
            }
            System.out.println(output_str);
        }
    }
 
    
}

Python代码

import functools
import collections
import math
from itertools import combinations
from re import match
 
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
 
#并查集模板
class UF:
    def __init__(self, n=0):
        self.count = n
        self.item = [0 for x in range(n+1)]
        for i in range(n):
            self.item[i] = i
    def find(self, x):
        if (x != self.item[x]):
            self.item[x] = self.find(self.item[x])
            return 0
        return x
    
 
    def union_connect(self, x, y):
        x_item = self.find(x)
        y_item = self.find(y)
    
        if (x_item != y_item):
            self.item[y_item] = x_item
            self.count-=1
 
 
 
# 处理输入
M = int(input())
N = int(input())
user_input = input()
 
# 表示各个芯片的剩余总容量
used = [M*1.25 for i in range(N)]
 
# 按照用户配置分配每一个容量
for i in range(len(user_input)):
    capacity = 0.0
    if (user_input[i] == 'A'):
        capacity = 1.25
    elif (user_input[i] == 'B'):
        capacity = 2.5
    else :
        capacity = 10
    
 
    # 从第一块芯片开始分配
    for j in range(N):
        if (used[j] >= capacity):
            used[j] -= capacity
            break
        
    
 
 
#输出
for j in range(N):
    output_str=""
    
    for k in range(M-int(used[j]/1.25)):
        output_str += '1'
    
    for i in range(int(used[j]/1.25)):
        output_str += "0"
    
    print(output_str)

JS代码

function main(M,N,user_input) {
 
    // 表示各个芯片的剩余总容量
    let used = new Array(N).fill(M*1.25)
 
    // 按照用户配置分配每一个容量
    for (let i=0;i<user_input.length;i++){
        let capacity = 0.0
        if (user_input[i] == 'A')
            capacity = 1.25
        else if (user_input[i] == 'B')
            capacity = 2.5
        else
            capacity = 10
        
 
        // 从第一块芯片开始分配
        for (let j=0;j<N;j++){
            if (used[j] >= capacity){
                used[j] -= capacity
                break
            }
        }
    }
            
        
 
 
    //输出
    for (let j=0;j<N;j++){
        let output_str=""
        
        for (let k=0;k<M-used[j]/1.25;k++){
            output_str += '1'
        }
        
        for (let i=0;i<used[j]/1.25;i++){
            output_str += "0"
        }
        
        console.log(output_str)
    }
 
 
}
 
 
main(8,2 ,"ACABA")

查看全文

http://www.kler.cn/a/6638.html