华为OD机试真题——通过软盘拷贝文件（2025A卷：200分）Java/python/JavaScript/C++/C语言/GO六种最佳实现
https://i-blog.csdnimg.cn/direct/7021e860899b4e5ba6934ae462dc1aab.png#pic_center2025 A卷 200分 题型
本文涵盖详细的问题分析、解题思路、代码实现、代码详解、测试用例以及综合分析；
并提供Java、python、JavaScript、C++、C语言、GO六种语言的最佳实现方式！
本文收录于专栏：《2025华为OD真题目次+全流程解析/备考攻略/履历分享》
华为OD机试真题《通过软盘拷贝文件》：
题目名称：通过软盘拷贝文件
[*]知识点：动态规划（01背包）
[*]时间限制：1秒
[*]空间限制：256MB
[*]限定语言：不限
题目形貌
科学家需要从古董电脑中拷贝文件到软盘，软盘容量为 1474560 字节。文件存储按块分配，每个块 512 字节，一个块只能被一个文件占用。文件必须完整拷贝且不压缩。目的是使软盘中文件总大小最大。
输入形貌
[*]第1行为整数 N，表示文件数目（1 ≤ N < 1000）。
[*]第2行到第N+1行，每行为一个整数，表示文件大小 Si（单元：字节，0 < Si ≤ 1000000）。
输出形貌
[*]输出科学家能拷贝的最大文件总大小。
示例
输入：
3
737270
737272
737288
输出：
1474542
说明
[*]文件块计算方式：每个文件大小向上取整到512的倍数。比方737270字节占用 ceil(737270/512) = 1440 块。
[*]软盘总块数为 1474560/512 = 2880 块。选择前两个文件占用 1440 + 1440 = 2880 块，总大小为 737270 + 737272 = 1474542 字节。
补充说明
[*]动态规划（01背包问题）或回溯法是典型解法。文件块为背包容量，文件大小为价值，需最大化总价值。
Java
问题分析
我们需要在给定多个文件的情况下，选择一些文件拷贝到软盘上，使得总块数不高出软盘容量，同时总文件大小最大。每个文件的大小按512字节向上取整计算块数。这是一个典型的0-1背包问题，此中背包容量是软盘的总块数，每个文件的体积是其块数，价值是文件实际大小。
解题思路
[*]块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
[*]动态规划：利用动态规划求解0-1背包问题。界说dp为容量i时的最大总价值。
[*]效果构造：遍历所有大概的容量，找到最大总价值。
代码实现
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt(); // 读取文件数量
int[] sizes = new int; // 存储每个文件的大小
for (int i = 0; i < N; i++) {
sizes = scanner.nextInt();
}
int totalBlocks = 1474560 / 512; // 软盘总块数2880
int[] dp = new int; // dp数组，dp表示容量i时的最大总价值
for (int size : sizes) { // 遍历每个文件
int blocks = (size + 511) / 512;
// 计算块数：向上取整
int value = size; // 价值是文件实际大小
// 逆序更新dp数组，确保每个文件只选一次
for (int j = totalBlocks; j >= blocks; j--) {
if (dp + value > dp) {
dp = dp + value;
}
}
}
// 找出dp数组中的最大值
int max = 0;
for (int j = 0; j <= totalBlocks; j++) {
if (dp > max) {
max = dp;
}
}
System.out.println(max);
}
}
代码详细解析
[*] 输入处理惩罚：
[*]Scanner读取输入，N为文件数目，sizes数组存储每个文件的大小。
[*] 块数计算：
[*]每个文件的块数通过(size + 511) / 512计算，实现向上取整。
[*] 动态规划数组初始化：
[*]dp数组长度为totalBlocks + 1，初始值为0。
[*] 动态规划过程：
[*]对每个文件，逆序遍历容量（从totalBlocks到当前文件块数），更新dp数组。
[*]逆序更新确保每个文件仅被思量一次，符合0-1背包要求。
[*] 效果提取：
[*]遍历dp数组，找到最大值即为答案。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]块数分别为1440、1440、1441。选中前两个文件，总块数2880，总价值1474542。
示例2输入：
2
513 1023
输出：
1023
解析：
[*]块数分别为2（513→2块）、2（1023→2块）。总块数4，容量2880远大于4。选1023。
示例3输入：
1
1474560
输出：
0
解析：
[*]块数2880，高出软盘容量2880？文件大小1474560恰好占用2880块，总和等于容量，输出1474560？
注意：示例3大概存在错误，实际块数为1474560 /512 = 2880块。若文件大小1474560，则块数2880，总块数刚好等于容量，应输出1474560。大概需要验证题目条件。
综合分析
[*]时间复杂度：O(N × M)，此中N为文件数目，M为总块数（2880）。满足题目时间限制。
[*]空间复杂度：O(M)，动态规划数组仅需线性空间。
[*]优势：
[*]动态规划高效办理背包问题。
[*]块数计算正确，确保正确性。
[*]实用场景：实用于文件数目大但总块数适中的场景。
python
问题分析
我们需要选择多少文件拷贝到软盘上，使得总块数不高出软盘容量，同时总文件大小最大。每个文件大小需向上取整到512字节的块数。这是典型的0-1背包问题，块数为容量，文件实际大小为价值。
解题思路
[*]块数计算：每个文件大小向上取整到512的倍数。
[*]动态规划：利用一维数组 dp 表示容量为 i 时的最大总价值。
[*]逆序更新：确保每个文件只被选择一次。
代码实现
def main(): import sys input = sys.stdin.read().split() idx = 0
N = int(input)# 读取文件数目 idx += 1 sizes = [] for _ in range(N): sizes.append(int(input))# 读取所有文件大小 idx += 1 total_blocks = 1474560 // 512# 总块数2880
dp = * (total_blocks + 1)# dp数组初始化 for size in sizes: # 计算块数：向上取整到512的倍数 blocks = (size + 511) // 512 # 文件实际大小即为价值 value = size # 逆序更新dp数组（避免重复选择） for j in range(total_blocks, blocks - 1, -1): if dp + value > dp: dp = dp + value # 找出能获得的最大价值（大概出现在任意容量） print(max(dp))if __name__ == "__main__": main() 代码详细解析
[*] 输入处理惩罚：
[*]利用 sys.stdin.read() 读取所有输入内容，分割成列表。
[*]N 表示文件数目，sizes 列表存储每个文件的大小。
[*] 块数计算：
[*](size + 511) // 512 实现向上取整。比方737270 → (737270+511)//512=1440块。
[*] 动态规划数组：
[*]dp = * (total_blocks + 1) 初始化数组，dp 表示容量i时的最大总价值。
[*] 核心状态转移：
[*]对每个文件，逆序（从 total_blocks 到 blocks）更新 dp 数组。
[*]逆序确保每个文件只被选择一次（01背包特性）。
[*] 效果输出：
[*]遍历 dp 数组找出最大值，即大概的最大总文件大小。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]块数分别为1440、1440、1441，总容量2880。选前两个文件，总大小737270+737272=1474542。
示例2输入：
2
513
1023
输出：
1023
解析：
[*]块数分别为2（513→2块）、2（1023→2块）。容量足够但选大文件更优。
示例3输入：
1
1474560
输出：
1474560
解析：
[*]块数2880刚好等于总容量，可以完整放入。
综合分析
[*] 时间复杂度：O(N×M)
[*]N为文件数目（<1000），M为总块数（2880），总操作次数约288万次，Python处理惩罚完全无压力。
[*] 空间复杂度：O(M)
[*]dp 数组仅需2881个元素，内存消耗极小。
[*] 优势：
[*]高效精准：动态规划严格包管最优解。
[*]空间优化：一维数组节流内存。
[*]代码轻便：核心逻辑仅10行。
[*] 实用场景：
[*]文件数目大（N接近1000）且单文件体积大（接近1MB）的场景。
JavaScript
问题分析
我们需要将文件拷贝到软盘上，软盘总容量为1474560字节，每个块512字节。每个文件的大小按512字节向上取整计算块数。目的是选择文件，使得总块数不高出软盘容量，且总文件大小最大。这是典型的0-1背包问题，此中背包容量是总块数，每个文件的体积是块数，价值是文件实际大小。
解题思路
[*]块数计算：每个文件大小向上取整到512的倍数。
[*]动态规划：利用一维数组 dp，dp 表示容量为 i 时的最大总价值。
[*]逆序更新：确保每个文件仅被选择一次。
代码实现
const readline = require('readline');const rl = readline.createInterface({input: process.stdin,output: process.stdout,terminal: false});let lines = [];rl.on('line', (line) => {lines.push(line.trim());});rl.on('close', () => {const N = parseInt(lines); // 读取文件数目const sizes = lines.slice(1, N + 1).map(Number); // 读取所有文件大小const totalBlocks = 1474560 / 512; // 软盘总块数2880
const dp = new Array(totalBlocks + 1).fill(0); // 初始化dp数组for (const size of sizes) { const blocks = Math.ceil(size / 512); // 计算当前文件块数 for (let j = totalBlocks; j >= blocks; j--) { dp = Math.max(dp, dp + size); // 逆序更新dp数组 }}console.log(Math.max(...dp)); // 输出最大总价值}); 代码详细解析
[*] 输入处理惩罚：
[*]readline 逐行读取输入，存入 lines 数组。
[*]lines 是文件数目 N，lines 是各文件大小。
[*] 块数计算：
[*]Math.ceil(size / 512) 将文件大小向上取整到512的倍数，得到块数。
[*] 动态规划数组：
[*]dp 数组长度为 totalBlocks + 1，初始化为0，表示容量为 i 时的最大总价值。
[*] 核心状态转移：
[*]对每个文件，逆序遍历容量（从 totalBlocks 到当前块数），更新 dp 数组。
[*]dp = Math.max(dp, dp + size) 确保每个文件仅被选一次。
[*] 效果输出：
[*]Math.max(...dp) 找出 dp 数组中的最大值，即最大总文件大小。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]块数分别为1440、1440、1441，总容量2880。选前两个文件，总大小1474542。
示例2输入：
2
513
1023
输出：
1023
解析：
[*]块数各为2，容量足够。选较大的文件1023。
示例3输入：
1
1474560
输出：
1474560
解析：
[*]块数2880等于容量，可完整放入。
综合分析
[*] 时间复杂度：O(N × M)
[*]N 为文件数目（≤1000），M 为总块数（2880）。总操作次数约288万次，效率较高。
[*] 空间复杂度：O(M)
[*]dp 数组仅需2881个元素，内存占用极小。
[*] 优势：
[*]动态规划：严格包管最优解，避免回溯法的指数复杂度。
[*]空间优化：一维数组实现节流内存。
[*]高效计算：块数计算和状态转移均高效。
[*] 实用场景：
[*]文件数目大（接近1000）且单文件体积大的场景。
C++
问题分析
我们需要将文件拷贝到软盘中，使得总块数不高出软盘容量，且总文件大小最大。每个文件的大小需向上取整到512字节的块数。这是一个典型的0-1背包问题，背包容量为软盘总块数，物品体积为文件块数，价值为文件实际大小。
解题思路
[*]块数计算：每个文件大小向上取整到512的倍数。
[*]动态规划：用一维数组 dp 表示容量为 i 时的最大总价值。
[*]逆序更新：确保每个文件仅被选择一次，避免重复计算。
代码实现
#include <iostream>#include <vector>#include <algorithm>// 用于max函数using namespace std;int main() { int N; cin >> N;// 读取文件数目 vector<int> sizes(N); for (int i = 0; i < N; ++i) { cin >> sizes;// 读取每个文件的大小 } const int total_blocks = 1474560 / 512;// 计算软盘总块数（2880） vector<int> dp(total_blocks + 1, 0); // dp数组，初始化为0
for (int s : sizes) {// 遍历每个文件 int blocks = (s + 511) / 512;// 计算当前文件占用的块数（向上取整） int value = s; // 价值为文件的实际大小 // 逆序更新dp数组，确保每个文件只选一次 for (int j = total_blocks; j >= blocks; --j) { dp = max(dp, dp + value); } } // 找出dp数组中的最大值（大概出现在任意位置） int max_value = *max_element(dp.begin(), dp.end()); cout << max_value << endl; return 0;} 代码详细解析
[*] 输入处理惩罚：
[*]cin >> N：读取文件数目。
[*]vector<int> sizes(N)：存储每个文件的大小。
[*] 块数计算：
[*](s + 511) / 512：向上取整到512的倍数。比方737270 → (737270+511)/512=1440块。
[*] 动态规划数组：
[*]vector<int> dp(total_blocks + 1, 0)：初始化数组，dp 表示容量 i 时的最大总价值。
[*] 状态转移：
[*]对每个文件，逆序遍历容量（从 total_blocks 到当前块数），更新 dp 数组。
[*]dp = max(dp, dp + value)：确保每个文件只被选择一次。
[*] 效果输出：
[*]max_element(dp.begin(), dp.end())：遍历 dp 数组找到最大值。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]块数分别为1440、1440、1441。选中前两个文件，总块数2880，总大小1474542。
示例2输入：
2
513
1023
输出：
1023
解析：
[*]块数各为2，容量足够但选更大的文件。
示例3输入：
1
1474560
输出：
1474560
解析：
[*]块数2880刚好等于容量，可完整放入。
综合分析
[*] 时间复杂度：O(N × M)
[*]N为文件数目（≤1000），M为总块数（2880）。总操作次数约288万次，高效。
[*] 空间复杂度：O(M)
[*]dp 数组仅需2881个元素，内存占用极小。
[*] 优势：
[*]动态规划：严格包管最优解，避免回溯法的指数复杂度。
[*]空间优化：一维数组节流内存。
[*]高效计算：块数计算和状态转移均高效。
[*] 实用场景：
[*]文件数目大（接近1000）且单文件体积大的场景。
C语言
问题分析
我们需要将文件拷贝到软盘中，使得总块数不高出软盘容量，且总文件大小最大。每个文件的大小按512字节向上取整计算块数。这是典型的0-1背包问题，背包容量为软盘总块数，物品体积为块数，价值为文件实际大小。
解题思路
[*]块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
[*]动态规划：用一维数组 dp 表示容量为 i 时的最大总价值。
[*]逆序更新：确保每个文件只被选择一次，避免重复计算。
代码实现
#include <stdio.h>#include <stdlib.h>#define MAX_BLOCKS 2880
// 软盘总块数: 1474560 / 512 = 2880#define MAX_FILES 1000
// 最大文件数目int main() { int N; scanf("%d", &N); // 读取文件数目 int sizes;// 存储所有文件大小 for (int i = 0; i < N; i++) { scanf("%d", &sizes); } // 初始化dp数组：dp表示容量为i时的最大总价值 int dp = {0};
// 全部初始化为0
// 遍历每个文件，更新dp数组 for (int i = 0; i < N; i++) { int size = sizes; int blocks = (size + 511) / 512;
// 向上取整计算块数 int value = size; // 价值为文件实际大小 // 逆序更新dp数组（确保每个文件只选一次） for (int j = MAX_BLOCKS; j >= blocks; j--) { if (dp + value > dp) { dp = dp + value; } } } // 找出dp数组中的最大值 int max_value = 0; for (int j = 0; j <= MAX_BLOCKS; j++) { if (dp > max_value) { max_value = dp; } } printf("%d\n", max_value); return 0;} 代码详细解析
1. 输入处理惩罚
int N;
scanf("%d", &N); // 读取文件数量
int sizes;// 存储所有文件大小
for (int i = 0; i < N; i++) {
scanf("%d", &sizes);
}
[*]作用：读取文件数目 N 和每个文件的大小 sizes。
[*]细节：MAX_FILES 界说为1000，支持最大输入文件数。
2. 块数计算
int blocks = (size + 511) / 512;
[*]公式：通过 (size + 511) / 512 实现向上取整。
[*]比方：size=737270 → (737270+511)/512 = 1440 块。
[*]数学原理：
若 size 能被512整除，则 size/512 = (size+511)/512。
若不能整除，余数部门会被进位。
3. 动态规划数组初始化
int dp = {0};
[*]界说：dp 表示容量为 i 时的最大总价值（即总文件大小）。
[*]初始值：所有元素初始化为0，表示未选择任何文件时的状态。
4. 核心状态转移
for (int j = MAX_BLOCKS; j >= blocks; j--) {
if (dp + value > dp) {
dp = dp + value;
}
}
[*]逆序更新：从 MAX_BLOCKS 到 blocks 逆序遍历，确保每个文件只被选一次。
[*]正序问题：若正序更新，会重复选择同一文件多次（变成完全背包问题）。
[*]状态转移方程：
dp = max(dp, dp + value)
即在容量 j 时，选择当前文件后的总价值是否比不选更大。
5. 效果输出
int max_value = 0;
for (int j = 0; j <= MAX_BLOCKS; j++) {
if (dp > max_value) {
max_value = dp;
}
}
printf("%d\n", max_value);
[*]遍历dp数组：找到所有容量下的最大总价值。
[*]输出效果：直接打印最大值，即能拷贝的最大文件总大小。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]文件块数分别为 1440、1440、1441，总容量为 2880。
[*]选择前两个文件，总块数 1440+1440=2880，总大小 737270+737272=1474542。
示例2输入：
2
513
1023
输出：
1023
解析：
[*]块数分别为 1（513→1块）、2（1023→2块），总容量允许选 1023。
[*]选第二个文件，总大小 1023。
示例3输入：
1
1474560
输出：
1474560
解析：
[*]块数为 1474560/512 = 2880，刚好占满软盘容量，可完整拷贝。
综合分析
1. 时间复杂度
[*]计算量：( O(N \times M) )，此中 ( N ) 为文件数目，( M ) 为软盘总块数（2880）。
[*]示例：若 ( N=1000 )，总操作次数为 ( 1000 \times 2880 = 2.88 \times 10^6 )，完全可在1秒内处理惩罚。
2. 空间复杂度
[*]内存占用：( O(M) )，此中 ( M=2880 )。
[*]dp 数组仅需2881个 int，约占用 ( 2881 \times 4 \text{ Bytes} ≈ 11.5 \text{ KB} )。
3. 优势
[*]严格最优解：动态规划包管找到全局最优解。
[*]空间高效：一维数组将空间复杂度从 ( O(N \times M) ) 优化到 ( O(M) )。
[*]计算高效：块数计算和状态转移均为 ( O(1) ) 操作。
4. 实用场景
[*]大规模数据：文件数目 ( N \leq 1000 )，单文件大小 ( \leq 1\text{MB} )。
[*]严格容量限制：需正确满足块数约束的场景（如硬件资源限制）。
GO
问题分析
我们需要将文件拷贝到软盘中，使得总块数不高出软盘容量（2880块），且总文件大小最大。每个文件的大小需向上取整到512字节的块数。这是典型的0-1背包问题，此中背包容量为总块数，物品体积为块数，价值为文件实际大小。
解题思路
[*]块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
[*]动态规划：用一维数组 dp 表示容量为 i 时的最大总价值。
[*]逆序更新：从高容量向低容量更新，确保每个文件只被选一次。
代码实现
package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
scanner.Scan()
N, _ := strconv.Atoi(scanner.Text()) // 读取文件数量
// 读取所有文件大小
sizes := make([]int, N)
for i := 0; i < N; i++ {
scanner.Scan()
size, _ := strconv.Atoi(scanner.Text())
sizes = size
}
const totalBlocks = 1474560 / 512 // 软盘总块数2880
dp := make([]int, totalBlocks+1)
// dp数组，dp表示容量i时的最大价值
// 动态规划核心逻辑
for _, size := range sizes {
blocks := (size + 511) / 512
// 计算块数（向上取整）
value := size // 价值为文件实际大小
// 逆序更新dp数组，确保每个文件只选一次
for j := totalBlocks; j >= blocks; j-- {
if dp+value > dp {
dp = dp + value
}
}
}
// 找出最大值
maxValue := 0
for _, v := range dp {
if v > maxValue {
maxValue = v
}
}
// 输出结果
fmt.Println(maxValue)
}
代码详细解析
1. 输入处理惩罚
scanner := bufio.NewScanner(os.Stdin)
scanner.Scan()
N, _ := strconv.Atoi(scanner.Text())
[*]作用：读取文件数目 N。
[*]细节：bufio.Scanner 逐行读取输入，strconv.Atoi 将字符串转为整数。
2. 读取文件大小
sizes := make([]int, N)
for i := 0; i < N; i++ {
scanner.Scan()
size, _ := strconv.Atoi(scanner.Text())
sizes = size
}
[*]作用：读取每个文件的大小存入切片 sizes。
[*]细节：循环 N 次，每次读取一行并转为整数。
3. 块数计算
blocks := (size + 511) / 512
[*]公式：向上取整到512的倍数。
[*]比方：size=737270 → (737270+511)/512=1440 块。
[*]数学原理：
若 size 能被512整除，则 size/512 = (size+511)/512。
若不能整除，余数部门会被进位。
4. 动态规划数组初始化
dp := make([]int, totalBlocks+1)
[*]界说：dp 表示容量为 i 时的最大总价值。
[*]初始值：所有元素默认初始化为0，表示未选择任何文件时的状态。
5. 核心状态转移
for j := totalBlocks; j >= blocks; j-- {
if dp+value > dp {
dp = dp + value
}
}
[*]逆序更新：从 totalBlocks 到 blocks 逆序遍历，确保每个文件只被选一次。
[*]正序问题：若正序更新，会重复选择同一文件多次（变成完全背包问题）。
[*]状态转移方程：
dp = max(dp, dp + value)
即在容量 j 时，选择当前文件后的总价值是否比不选更大。
6. 效果输出
maxValue := 0
for _, v := range dp {
if v > maxValue {
maxValue = v
}
}
fmt.Println(maxValue)
[*]遍历dp数组：找到所有容量下的最大总价值。
[*]输出效果：直接打印最大值，即能拷贝的最大文件总大小。
示例测试
示例1输入：
3
737270
737272
737288
输出：
1474542
解析：
[*]文件块数分别为 1440、1440、1441，总容量为 2880。
[*]选择前两个文件，总块数 1440+1440=2880，总大小 737270+737272=1474542。
示例2输入：
2
513
1023
输出：
1023
解析：
[*]块数分别为 1（513→1块）、2（1023→2块），总容量允许选 1023。
[*]选第二个文件，总大小 1023。
示例3输入：
1
1474560
输出：
1474560
解析：
[*]块数为 1474560/512 = 2880，刚好占满软盘容量，可完整拷贝。
综合分析
[*] 时间复杂度：( O(N \times M) )
[*]( N ) 为文件数目（≤1000），( M ) 为总块数（2880）。总操作次数约288万次，Go处理惩罚高效。
[*] 空间复杂度：( O(M) )
[*]dp 数组仅需2881个元素，内存占用约23KB（每个int占4字节）。
[*] 优势：
[*]严格最优解：动态规划包管全局最优。
[*]空间高效：一维数组节流内存。
[*]代码轻便：核心逻辑仅需10行。
[*] 实用场景：
[*]文件数目大（接近1000）且单文件体积大的场景。
更多内容：
https://www.kdocs.cn/l/cvk0eoGYucWA
本文发表于【纪元A梦】，关注我，获取更多实用教程/资源！
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]