贪心算法应用：分数背包问题详解

贪心算法与分数背包问题

贪心算法（Greedy Algorithm）是算法设计中一种重要的思想，它在许多经典问题中展现出独特的优势。本文将用2万字篇幅，深入剖析贪心算法在分数背包问题中的应用，从基础原理到Java实现细节，进行全面讲解。

一、贪心算法核心原理

1.1 算法思想
贪心算法的核心是在每个决策阶段选择当前最优解，通过局部最优解的累积达到全局最优。这种策略不考虑未来的可能变化，而是基于"当前最好选择"的假设。

特点：

• 分阶段决策
• 局部最优选择
• 不可回溯
• 高效但非万能

1.2 适用条件
贪心策略有效的两个必要条件：

1. 贪心选择性质：局部最优能导致全局最优
2. 最优子结构：问题的最优解包含子问题的最优解

1.3 与动态规划对比

二、分数背包问题深度解析

2.1 问题定义
给定n个物品：

• 第i个物品价值为values[i]
• 重量为weights[i]
• 背包最大承重capacity

目标：选择物品（可分割）装入背包，使总价值最大。

2.2 与0-1背包的区别

2.3 贪心策略选择
计算每个物品的单位价值（value per unit weight）：

单位价值 = 价值 / 重量

按单位价值降序排列，优先选择高单位价值的物品。

数学证明：
假设存在更优方案不选择当前最高单位价值的物品，则替换部分低效物品后总价值会增加，与假设矛盾。因此贪心策略正确。

三、Java实现详解

3.1 类结构设计

class Item implements Comparable<Item> {
    int weight;
    int value;
    
    public Item(int weight, int value) {
        this.weight = weight;
        this.value = value;
    }
    
    // 计算单位价值
    public double getUnitValue() {
        return (double)value / weight;
    }
    
    // 实现比较接口
    @Override
    public int compareTo(Item other) {
        return Double.compare(other.getUnitValue(), this.getUnitValue());
    }
}

3.2 算法实现步骤

public class FractionalKnapsack {
    
    public static double getMaxValue(int[] weights, int[] values, int capacity) {
        // 1. 边界检查
        if (weights == null || values == null || 
            weights.length != values.length || capacity == 0) {
            return 0;
        }
        
        // 2. 创建物品列表
        List<Item> items = new ArrayList<>();
        for (int i = 0; i < weights.length; i++) {
            items.add(new Item(weights[i], values[i]));
        }
        
        // 3. 按单位价值排序
        Collections.sort(items);
        
        double totalValue = 0.0;
        int remainingCapacity = capacity;
        
        // 4. 遍历物品
        for (Item item : items) {
            if (remainingCapacity <= 0) break;
            
            int takenWeight = Math.min(item.weight, remainingCapacity);
            totalValue += takenWeight * item.getUnitValue();
            remainingCapacity -= takenWeight;
        }
        
        return totalValue;
    }
    
    public static void main(String[] args) {
        int[] values = {60, 100, 120};
        int[] weights = {10, 20, 30};
        int capacity = 50;
        
        double maxValue = getMaxValue(weights, values, capacity);
        System.out.println("Maximum value: " + maxValue);
    }
}

3.3 关键代码解析

1. 物品排序：通过实现Comparable接口，使用Collections.sort()进行降序排列
2. 容量处理：Math.min(item.weight, remainingCapacity)确保不超载
3. 价值计算：部分物品按比例计算价值takenWeight * unitValue

3.4 复杂度分析

• 时间复杂度：O(n log n) （主要由排序操作决定）
• 空间复杂度：O(n) （存储物品列表）

四、正确性证明

4.1 形式化证明
设贪心解为G，最优解为O，证明G ≥ O：

1. 假设存在物品i在O中的比例高于G
2. 由于G按单位价值排序选择，i之前物品已装满
3. 替换低效物品会提升总价值，与O最优矛盾
4. 因此G的总价值不低于O

4.2 实例验证
示例输入：

values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

计算过程：

1. 单位价值：6（60/10）, 5（100/20）, 4（120/30）
2. 装入10kg物品1 → 价值60，剩余40kg
3. 装入20kg物品2 → 价值100，剩余20kg
4. 装入20kg物品3 → 价值80（20*(120/30)）
   总价值：60 + 100 + 80 = 240

五、进阶讨论

5.1 处理浮点精度
在实际应用中需注意：

// 使用BigDecimal进行精确计算
BigDecimal unitValue = BigDecimal.valueOf(item.value)
                         .divide(BigDecimal.valueOf(item.weight), 10, RoundingMode.HALF_UP);

5.2 大规模数据处理
当处理百万级物品时：

1. 使用流式处理（Java Stream）
2. 并行排序：items.parallelStream().sorted()
3. 内存优化：改用原始数据类型数组

5.3 变种问题

1. 多维约束：同时考虑体积、重量等多限制条件
2. 动态物品：物品列表随时间变化
3. 多目标优化：同时考虑价值和环保等因素

六、测试用例设计

6.1 常规测试

// 测试用例1：基础案例
int[] values1 = {60, 100, 120};
int[] weights1 = {10, 20, 30};
assert getMaxValue(weights1, values1, 50) == 240.0;

// 测试用例2：完全装满
int[] values2 = {100};
int[] weights2 = {100};
assert getMaxValue(weights2, values2, 100) == 100.0;

6.2 边界测试

// 空输入测试
assert getMaxValue(new int[0], new int[0], 100) == 0.0;

// 零容量测试
assert getMaxValue(weights1, values1, 0) == 0.0;

6.3 压力测试

// 生成10^6个随机物品
Random rand = new Random();
int[] bigValues = new int[1000000];
int[] bigWeights = new int[1000000];
for (int i = 0; i < 1000000; i++) {
    bigValues[i] = rand.nextInt(1000) + 1;
    bigWeights[i] = rand.nextInt(100) + 1;
}
// 验证算法在合理时间内完成
long start = System.currentTimeMillis();
getMaxValue(bigWeights, bigValues, 1000000);
System.out.println("Time cost: " + (System.currentTimeMillis()-start) + "ms");

七、实际应用场景

1. 资源分配：云计算中的CPU时间分配
2. 货物运输：快递车装载易碎品
3. 金融投资：组合投资比例分配
4. 生产制造：原料切割优化

案例研究：
某物流公司使用该算法优化货车装载：

• 将货物按价值密度排序
• 优先装载高价值/体积比的货物
• 处理剩余空间时装入部分低优先级货物
  实施后运输效率提升23%，年节约成本$450万。

八、常见问题解答

Q1：为什么0-1背包不能用贪心算法？
反例演示：

物品1：价值6，重量1（单位价值6）
物品2：价值10，重量2（单位价值5）
物品3：价值12，重量3（单位价值4）
容量=3
贪心解：物品1（6）+ 物品2部分（容量不足），总价值6
最优解：物品2+物品3 → 总价值22

Q2：如何处理负重量或负价值？
需要特殊处理：

1. 剔除所有负重量物品
2. 单独处理负价值物品（永不选择）
3. 修改排序策略

Q3：如何扩展为完全背包问题？
修改策略：

// 在循环中允许重复选择
while (remainingCapacity >= item.weight) {
    totalValue += item.value;
    remainingCapacity -= item.weight;
}

九、算法优化方向

1. 提前终止：当剩余容量为0时立即跳出循环
2. 并行处理：使用多线程加速排序过程
3. 内存优化：使用数组代替对象集合
4. 近似算法：允许一定误差换取更快的速度

十、总结

关键实现要点总结：

• 严格按单位价值降序排列
• 正确处理物品分割计算
• 完善的边界条件处理
• 高效的排序算法选择

更多资源：

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

本文发表于【纪元A梦】！