二分查找与贪心算法解决物流运输问题

1. 问题背景与需求分析

1011. Capacity To Ship Packages Within D Days 是 LeetCode 上一个经典的二分查找与贪心算法结合的题目。题目要求我们确定一艘船的最低运载能力，使得它能在 D 天内按顺序运输所有包裹。这个问题在实际物流调度、资源分配等场景中都有广泛应用。

1.1 题目描述解析

给定一个 weights 数组表示包裹重量，D 表示运输天数。我们需要找到一个最小的运载能力 capacity，使得：

• 每天运输的包裹必须是连续的
• 每天运输的总重量不超过 capacity
• 所有包裹必须在 D 天内运输完毕

例如：
输入：weights = [1,2,3,4,5,6,7,8,9,10], D = 5
输出：15
解释：
第1天：1,2,3,4,5
第2天：6,7
第3天：8
第4天：9
第5天：10

1.2 实际应用场景

这个问题在现实中有多个应用场景：

1. 物流运输：确定卡车的最低载重量以满足配送时限
2. 生产调度：安排机器的最小处理能力以完成生产任务
3. 资源分配：计算服务器的最小配置来处理批量作业

2. 算法思路与设计

2.1 暴力解法的问题

最直观的解法是从最小可能的 capacity 开始尝试，逐步增加直到找到满足条件的解。但是：

• 最小 capacity 是最大单个包裹重量
• 最大 capacity 是所有包裹重量之和
• 这种线性搜索在最坏情况下时间复杂度为 O(n*sum)，效率太低

2.2 二分查找优化

我们可以利用二分查找将时间复杂度优化到 O(n log sum)：

1. 确定搜索范围：left = max(weights), right = sum(weights)
2. 计算中间值 mid = (left + right) / 2
3. 检查 mid 是否满足 D 天内运输的条件
4. 根据检查结果调整搜索范围

2.3 贪心验证函数

关键是如何高效验证给定 capacity 是否满足条件：

c复制bool canShip(int* weights, int weightsSize, int D, int capacity) {
    int days = 1;
    int current = 0;
    
    for (int i = 0; i < weightsSize; i++) {
        if (current + weights[i] > capacity) {
            days++;
            current = 0;
        }
        current += weights[i];
    }
    
    return days <= D;
}

3. C语言实现详解

3.1 完整解决方案代码

c复制#include <stdbool.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int sum(int* weights, int weightsSize) {
    int total = 0;
    for (int i = 0; i < weightsSize; i++) {
        total += weights[i];
    }
    return total;
}

bool canShip(int* weights, int weightsSize, int D, int capacity) {
    int days = 1;
    int current = 0;
    
    for (int i = 0; i < weightsSize; i++) {
        if (current + weights[i] > capacity) {
            days++;
            current = 0;
        }
        current += weights[i];
    }
    
    return days <= D;
}

int shipWithinDays(int* weights, int weightsSize, int D) {
    int left = 0;
    int right = 0;
    
    for (int i = 0; i < weightsSize; i++) {
        left = max(left, weights[i]);
        right += weights[i];
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canShip(weights, weightsSize, D, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

3.2 关键代码解析

1. 边界确定：

   • left 初始化为最大单个包裹重量（至少能运最重的包裹）
   • right 初始化为所有包裹重量之和（一天运完所有包裹）

2. 二分查找：

   • 使用 left + (right - left)/2 避免整数溢出
   • 当 canShip 返回 true 时，尝试更小的 capacity
   • 否则需要增大 capacity

3. 验证函数：

   • 模拟每天的运输过程
   • 当累计重量超过 capacity 时，增加天数
   • 最后检查总天数是否 ≤ D

4. 算法复杂度分析

4.1 时间复杂度

1. 计算 sum 和 max：O(n)
2. 二分查找：O(log(sum - max))
3. 每次验证：O(n)
   总时间复杂度：O(n log(sum - max))

4.2 空间复杂度

只使用了常数个额外变量：O(1)

5. 边界条件与测试案例

5.1 常见测试案例

c复制// 案例1：基本测试
int weights1[] = {1,2,3,4,5,6,7,8,9,10};
assert(shipWithinDays(weights1, 10, 5) == 15);

// 案例2：D=1
int weights2[] = {1,2,3,4,5};
assert(shipWithinDays(weights2, 5, 1) == 15);

// 案例3：D等于数组长度
int weights3[] = {3,2,2,4,1,4};
assert(shipWithinDays(weights3, 6, 6) == 4);

// 案例4：大数测试
int weights4[] = {100,200,300,400,500};
assert(shipWithinDays(weights4, 5, 3) == 900);

5.2 边界情况处理

1. 单个包裹：weights = [5], D = 1 → 返回5
2. 所有包裹重量相同：weights = [2,2,2], D = 2 → 返回4
3. D大于数组长度：应该返回最大单个重量（题目保证D <= weightsSize）

6. 优化与变种思考

6.1 可能的优化方向

1. 并行计算：对于超大数组，可以并行计算 sum 和 max
2. 提前终止：在验证函数中，如果 days 已经超过 D 可以提前返回
3. 初始范围优化：可以根据平均值估算更精确的初始范围

6.2 相关问题变种

1. 非连续运输：允许选择任意包裹组合（更难，类似背包问题）
2. 多船运输：有多个运输工具可用
3. 动态重量：包裹重量随时间变化

7. 实际应用中的注意事项

1. 内存限制：对于极大数组，需要考虑内存使用
2. 浮点重量：实际应用中重量可能是浮点数，需要调整比较方式
3. 运输顺序：实际问题中可能有运输顺序限制
4. 实时调整：运输能力可能需要动态调整

提示：在工业级实现中，通常会加入更复杂的约束条件检查，如运输工具的可用性、装卸时间等。

8. 常见错误与调试技巧

8.1 常见错误

1. 初始范围错误：left 未设置为 max(weights)
2. 整数溢出：使用 (left + right)/2 而不是 left + (right-left)/2
3. 天数计算错误：未正确重置 current 或未初始化 days=1
4. 边界条件：处理 D=1 或 D=weightsSize 的情况

8.2 调试建议

1. 打印中间值：在二分循环中打印 left, right, mid
2. 小案例测试：先用简单案例验证
3. 单步调试：检查验证函数的执行过程
4. 极端测试：测试超大数组或极值情况

9. 性能对比实测

在我的测试环境中（i7-10750H，16GB RAM），对不同规模输入的运行时间：

可以看到二分查找算法在大规模数据下的优势非常明显。

10. 扩展学习资源

1. 类似题目：

   • 875. Koko Eating Bananas
   • 410. Split Array Largest Sum
   • 1482. Minimum Number of Days to Make m Bouquets

2. 进阶算法：

   • 动态规划解法（适用于变种问题）
   • 遗传算法（超大规模优化）
   • 线性规划（带复杂约束）

3. 推荐学习资料：

   • 《算法导论》中的二分查找和贪心算法章节
   • LeetCode 二分查找专题
   • Topcoder 算法教程

在实际编码面试中，这类问题考察的是对基础算法的灵活应用能力。建议在理解这个解法后，尝试自己从头实现几次，并思考各种变种情况的处理方法。我在最初解决这个问题时，最大的收获是认识到二分查找不仅适用于有序数组查找，还可以用于这种"寻找最小最大值"的优化问题。