华为OD机试真题——通过软盘拷贝文件（2025A卷：200分）Java/python/JavaScript/C++/C语言/GO六种最佳实现

纪元A梦2025-04-25 15:40

2025 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背包问题，其中背包容量是软盘的总块数，每个文件的体积是其块数，价值是文件实际大小。

解题思路

  1. 块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
  2. 动态规划 ：使用动态规划求解0-1背包问题。定义dp[i]为容量i时的最大总价值。
  3. 结果构造：遍历所有可能的容量，找到最大总价值。

代码实现

java 复制代码 
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[N]; // 存储每个文件的大小
        for (int i = 0; i < N; i++) {
            sizes[i] = scanner.nextInt();
        }
        
        int totalBlocks = 1474560 / 512; // 软盘总块数2880
        int[] dp = new int[totalBlocks + 1]; // dp数组，dp[i]表示容量i时的最大总价值
        
        for (int size : sizes) { // 遍历每个文件
            int blocks = (size + 511) / 512; // 计算块数：向上取整
            int value = size; // 价值是文件实际大小
            
            // 逆序更新dp数组，确保每个文件只选一次
            for (int j = totalBlocks; j >= blocks; j--) {
                if (dp[j - blocks] + value > dp[j]) {
                    dp[j] = dp[j - blocks] + value;
                }
            }
        }
        
        // 找出dp数组中的最大值
        int max = 0;
        for (int j = 0; j <= totalBlocks; j++) {
            if (dp[j] > max) {
                max = dp[j];
            }
        }
        System.out.println(max);
    }
}

代码详细解析

  1. 输入处理：

    • Scanner读取输入，N为文件数量，sizes数组存储每个文件的大小。

  2. 块数计算：

    • 每个文件的块数通过(size + 511) / 512计算，实现向上取整。

  3. 动态规划数组初始化：

    • dp数组长度为totalBlocks + 1，初始值为0。

  4. 动态规划过程：

    • 对每个文件，逆序遍历容量（从totalBlocks到当前文件块数），更新dp数组。
    • 逆序更新确保每个文件仅被考虑一次，符合0-1背包要求。

  5. 结果提取：

    • 遍历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。可能需要验证题目条件。

综合分析

  1. 时间复杂度：O(N × M)，其中N为文件数量，M为总块数（2880）。满足题目时间限制。
  2. 空间复杂度：O(M)，动态规划数组仅需线性空间。
  3. 优势 ：
    • 动态规划高效解决背包问题。
    • 块数计算准确，确保正确性。
  4. 适用场景：适用于文件数量大但总块数适中的场景。

python

问题分析

我们需要选择若干文件拷贝到软盘上，使得总块数不超过软盘容量，同时总文件大小最大。每个文件大小需向上取整到512字节的块数。这是典型的0-1背包问题，块数为容量，文件实际大小为价值。

解题思路

  1. 块数计算：每个文件大小向上取整到512的倍数。
  2. 动态规划 ：使用一维数组 dp 表示容量为 i 时的最大总价值。
  3. 逆序更新：确保每个文件只被选择一次。

代码实现

python 复制代码 
def main():
    import sys
    input = sys.stdin.read().split()
    idx = 0
    N = int(input[idx])  # 读取文件数量
    idx += 1
    
    sizes = []
    for _ in range(N):
        sizes.append(int(input[idx]))  # 读取所有文件大小
        idx += 1
    
    total_blocks = 1474560 // 512  # 总块数2880
    dp = [0] * (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[j - blocks] + value > dp[j]:
                dp[j] = dp[j - blocks] + value
                
    # 找出能获得的最大价值（可能出现在任意容量）
    print(max(dp))

if __name__ == "__main__":
    main()

代码详细解析

  1. 输入处理：

    • 使用 sys.stdin.read() 读取所有输入内容，分割成列表。
    • N 表示文件数量，sizes 列表存储每个文件的大小。

  2. 块数计算：

    • (size + 511) // 512 实现向上取整。例如737270 → (737270+511)//512=1440块。

  3. 动态规划数组：

    • dp = [0] * (total_blocks + 1) 初始化数组，dp[i] 表示容量i时的最大总价值。

  4. 核心状态转移：

    • 对每个文件，逆序（从 total_blocks 到 blocks）更新 dp 数组。
    • 逆序确保每个文件只被选择一次（01背包特性）。

  5. 结果输出：

    • 遍历 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刚好等于总容量，可以完整放入。

综合分析

  1. 时间复杂度：O(N×M)

    • N为文件数量（<1000），M为总块数（2880），总操作次数约288万次，Python处理完全无压力。

  2. 空间复杂度：O(M)

    • dp 数组仅需2881个元素，内存消耗极小。

  3. 优势：

    • 高效精准：动态规划严格保证最优解。
    • 空间优化：一维数组节省内存。
    • 代码简洁：核心逻辑仅10行。

  4. 适用场景：

    • 文件数量大（N接近1000）且单文件体积大（接近1MB）的场景。

JavaScript

问题分析

我们需要将文件拷贝到软盘上，软盘总容量为1474560字节，每个块512字节。每个文件的大小按512字节向上取整计算块数。目标是选择文件，使得总块数不超过软盘容量，且总文件大小最大。这是典型的0-1背包问题，其中背包容量是总块数，每个文件的体积是块数，价值是文件实际大小。

解题思路

  1. 块数计算：每个文件大小向上取整到512的倍数。
  2. 动态规划 ：使用一维数组 dp，dp[i] 表示容量为 i 时的最大总价值。
  3. 逆序更新：确保每个文件仅被选择一次。

代码实现

javascript 复制代码 
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[0]); // 读取文件数量
  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[j] = Math.max(dp[j], dp[j - blocks] + size); // 逆序更新dp数组
    }
  }

  console.log(Math.max(...dp)); // 输出最大总价值
});

代码详细解析

  1. 输入处理：

    • readline 逐行读取输入，存入 lines 数组。
    • lines[0] 是文件数量 N，lines[1..N] 是各文件大小。

  2. 块数计算：

    • Math.ceil(size / 512) 将文件大小向上取整到512的倍数，得到块数。

  3. 动态规划数组：

    • dp 数组长度为 totalBlocks + 1，初始化为0，表示容量为 i 时的最大总价值。

  4. 核心状态转移：

    • 对每个文件，逆序遍历容量（从 totalBlocks 到当前块数），更新 dp 数组。
    • dp[j] = Math.max(dp[j], dp[j - blocks] + size) 确保每个文件仅被选一次。

  5. 结果输出：

    • 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等于容量，可完整放入。

综合分析

  1. 时间复杂度：O(N × M)

    • N 为文件数量（≤1000），M 为总块数（2880）。总操作次数约288万次，效率较高。

  2. 空间复杂度：O(M)

    • dp 数组仅需2881个元素，内存占用极小。

  3. 优势：

    • 动态规划：严格保证最优解，避免回溯法的指数复杂度。
    • 空间优化：一维数组实现节省内存。
    • 高效计算：块数计算和状态转移均高效。

  4. 适用场景：

    • 文件数量大（接近1000）且单文件体积大的场景。

C++

问题分析

我们需要将文件拷贝到软盘中，使得总块数不超过软盘容量，且总文件大小最大。每个文件的大小需向上取整到512字节的块数。这是一个典型的0-1背包问题，背包容量为软盘总块数，物品体积为文件块数，价值为文件实际大小。

解题思路

  1. 块数计算：每个文件大小向上取整到512的倍数。
  2. 动态规划 ：用一维数组 dp 表示容量为 i 时的最大总价值。
  3. 逆序更新：确保每个文件仅被选择一次，避免重复计算。

代码实现

cpp 复制代码 
#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[i];  // 读取每个文件的大小
    }

    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[j] = max(dp[j], dp[j - blocks] + value);
        }
    }

    // 找出dp数组中的最大值（可能出现在任意位置）
    int max_value = *max_element(dp.begin(), dp.end());
    cout << max_value << endl;

    return 0;
}

代码详细解析

  1. 输入处理：

    • cin >> N：读取文件数量。
    • vector<int> sizes(N)：存储每个文件的大小。

  2. 块数计算：

    • (s + 511) / 512：向上取整到512的倍数。例如737270 → (737270+511)/512=1440块。

  3. 动态规划数组：

    • vector<int> dp(total_blocks + 1, 0)：初始化数组，dp[i] 表示容量 i 时的最大总价值。

  4. 状态转移：

    • 对每个文件，逆序遍历容量（从 total_blocks 到当前块数），更新 dp 数组。
    • dp[j] = max(dp[j], dp[j - blocks] + value)：确保每个文件只被选择一次。

  5. 结果输出：

    • 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刚好等于容量，可完整放入。

综合分析

  1. 时间复杂度：O(N × M)

    • N为文件数量（≤1000），M为总块数（2880）。总操作次数约288万次，高效。

  2. 空间复杂度：O(M)

    • dp 数组仅需2881个元素，内存占用极小。

  3. 优势：

    • 动态规划：严格保证最优解，避免回溯法的指数复杂度。
    • 空间优化：一维数组节省内存。
    • 高效计算：块数计算和状态转移均高效。

  4. 适用场景：

    • 文件数量大（接近1000）且单文件体积大的场景。

C语言

问题分析

我们需要将文件拷贝到软盘中，使得总块数不超过软盘容量，且总文件大小最大。每个文件的大小按512字节向上取整计算块数。这是典型的0-1背包问题，背包容量为软盘总块数，物品体积为块数，价值为文件实际大小。

解题思路

  1. 块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
  2. 动态规划 ：用一维数组 dp 表示容量为 i 时的最大总价值。
  3. 逆序更新：确保每个文件只被选择一次，避免重复计算。

代码实现

c 复制代码 
#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[MAX_FILES];  // 存储所有文件大小
    for (int i = 0; i < N; i++) {
        scanf("%d", &sizes[i]); 
    }
    
    // 初始化dp数组：dp[i]表示容量为i时的最大总价值
    int dp[MAX_BLOCKS + 1] = {0};  // 全部初始化为0
    
    // 遍历每个文件，更新dp数组
    for (int i = 0; i < N; i++) {
        int size = sizes[i];
        int blocks = (size + 511) / 512;  // 向上取整计算块数
        int value = size;                 // 价值为文件实际大小
        
        // 逆序更新dp数组（确保每个文件只选一次）
        for (int j = MAX_BLOCKS; j >= blocks; j--) {
            if (dp[j - blocks] + value > dp[j]) {
                dp[j] = dp[j - blocks] + value;
            }
        }
    }
    
    // 找出dp数组中的最大值
    int max_value = 0;
    for (int j = 0; j <= MAX_BLOCKS; j++) {
        if (dp[j] > max_value) {
            max_value = dp[j];
        }
    }
    
    printf("%d\n", max_value);
    return 0;
}

代码详细解析

1. 输入处理
c 复制代码 
int N;
scanf("%d", &N);       // 读取文件数量
int sizes[MAX_FILES];  // 存储所有文件大小
for (int i = 0; i < N; i++) {
    scanf("%d", &sizes[i]); 
}
  • 作用 ：读取文件数量 N 和每个文件的大小 sizes[i]。
  • 细节 ：MAX_FILES 定义为1000，支持最大输入文件数。
2. 块数计算
c 复制代码 
int blocks = (size + 511) / 512;
  • 公式 ：通过 (size + 511) / 512 实现向上取整。
    • 例如：size=737270 → (737270+511)/512 = 1440 块。
  • 数学原理 ：
    若 size 能被512整除，则 size/512 = (size+511)/512。
    若不能整除，余数部分会被进位。
3. 动态规划数组初始化
c 复制代码 
int dp[MAX_BLOCKS + 1] = {0};
  • 定义 ：dp[i] 表示容量为 i 时的最大总价值（即总文件大小）。
  • 初始值：所有元素初始化为0，表示未选择任何文件时的状态。
4. 核心状态转移
c 复制代码 
for (int j = MAX_BLOCKS; j >= blocks; j--) {
    if (dp[j - blocks] + value > dp[j]) {
        dp[j] = dp[j - blocks] + value;
    }
}
  • 逆序更新 ：从 MAX_BLOCKS 到 blocks 逆序遍历，确保每个文件只被选一次。
    • 正序问题：若正序更新，会重复选择同一文件多次（变成完全背包问题）。
  • 状态转移方程 ：
    dp[j] = max(dp[j], dp[j - blocks] + value)
    即在容量 j 时，选择当前文件后的总价值是否比不选更大。
5. 结果输出
c 复制代码 
int max_value = 0;
for (int j = 0; j <= MAX_BLOCKS; j++) {
    if (dp[j] > max_value) {
        max_value = dp[j];
    }
}
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背包问题，其中背包容量为总块数，物品体积为块数，价值为文件实际大小。

解题思路

  1. 块数计算：对每个文件大小，计算其占用的块数（向上取整到512的倍数）。
  2. 动态规划 ：用一维数组 dp 表示容量为 i 时的最大总价值。
  3. 逆序更新：从高容量向低容量更新，确保每个文件只被选一次。

代码实现

go 复制代码 
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[i] = size
	}

	const totalBlocks = 1474560 / 512 // 软盘总块数2880
	dp := make([]int, totalBlocks+1)  // dp数组，dp[i]表示容量i时的最大价值

	// 动态规划核心逻辑
	for _, size := range sizes {
		blocks := (size + 511) / 512 // 计算块数（向上取整）
		value := size                // 价值为文件实际大小

		// 逆序更新dp数组，确保每个文件只选一次
		for j := totalBlocks; j >= blocks; j-- {
			if dp[j-blocks]+value > dp[j] {
				dp[j] = dp[j-blocks] + value
			}
		}
	}

	// 找出最大值
	maxValue := 0
	for _, v := range dp {
		if v > maxValue {
			maxValue = v
		}
	}

	// 输出结果
	fmt.Println(maxValue)
}

代码详细解析

1. 输入处理
go 复制代码 
scanner := bufio.NewScanner(os.Stdin)
scanner.Scan()
N, _ := strconv.Atoi(scanner.Text())
  • 作用 ：读取文件数量 N。
  • 细节 ：bufio.Scanner 逐行读取输入，strconv.Atoi 将字符串转为整数。
2. 读取文件大小
go 复制代码 
sizes := make([]int, N)
for i := 0; i < N; i++ {
    scanner.Scan()
    size, _ := strconv.Atoi(scanner.Text())
    sizes[i] = size
}
  • 作用 ：读取每个文件的大小存入切片 sizes。
  • 细节 ：循环 N 次，每次读取一行并转为整数。
3. 块数计算
go 复制代码 
blocks := (size + 511) / 512
  • 公式 ：向上取整到512的倍数。
    • 例如：size=737270 → (737270+511)/512=1440 块。
  • 数学原理 ：
    若 size 能被512整除，则 size/512 = (size+511)/512。
    若不能整除，余数部分会被进位。
4. 动态规划数组初始化
go 复制代码 
dp := make([]int, totalBlocks+1)
  • 定义 ：dp[i] 表示容量为 i 时的最大总价值。
  • 初始值：所有元素默认初始化为0，表示未选择任何文件时的状态。
5. 核心状态转移
go 复制代码 
for j := totalBlocks; j >= blocks; j-- {
    if dp[j-blocks]+value > dp[j] {
        dp[j] = dp[j-blocks] + value
    }
}
  • 逆序更新 ：从 totalBlocks 到 blocks 逆序遍历，确保每个文件只被选一次。
    • 正序问题：若正序更新，会重复选择同一文件多次（变成完全背包问题）。
  • 状态转移方程 ：
    dp[j] = max(dp[j], dp[j - blocks] + value)
    即在容量 j 时，选择当前文件后的总价值是否比不选更大。
6. 结果输出
go 复制代码 
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，刚好占满软盘容量，可完整拷贝。

综合分析

  1. 时间复杂度：( O(N \times M) )

    • ( N ) 为文件数量（≤1000），( M ) 为总块数（2880）。总操作次数约288万次，Go处理高效。

  2. 空间复杂度：( O(M) )

    • dp 数组仅需2881个元素，内存占用约23KB（每个int占4字节）。

  3. 优势：

    • 严格最优解：动态规划保证全局最优。
    • 空间高效：一维数组节省内存。
    • 代码简洁：核心逻辑仅需10行。

  4. 适用场景：

    • 文件数量大（接近1000）且单文件体积大的场景。

更多内容：

https://www.kdocs.cn/l/cvk0eoGYucWA

本文发表于【纪元A梦】，关注我，获取更多实用教程/资源！

相关推荐
盖世英雄酱58136几秒前
分布式ID所有生成方案
java·后端
敖云岚14 分钟前
【AI】SpringAI 第五弹：接入千帆大模型
java·大数据·人工智能·spring boot·后端
桦说编程20 分钟前
CompletableFuture典型错误 -- 代码出自某大厂
java·后端·响应式编程
三道杠卷胡23 分钟前
【AI News | 20250424】每日AI进展
人工智能·pytorch·python·语言模型·github
root666/29 分钟前
【大数据技术-联邦集群RBF】DFSRouter日志一直打印修改Membership为EXPIRED状态的日志分析
java·大数据·hadoop
佩奇的技术笔记33 分钟前
Java学习手册：Filter 和 Listener
java
sugar__salt42 分钟前
反射，枚举，lambda表达式
java
Spring小子1 小时前
黑马点评商户查询缓存--缓存更新策略
java·数据库·redis·后端
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04✨分享我在飞书多维表格中使用DeepSeek的经历✨05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06苍穹外卖面试总结07Coze扣子平台完整体验和实践（附国内和国际版对比）08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09DeepSeek各版本说明与优缺点分析10如何在WPS和Word/Excel中直接使用DeepSeek功能