二分查找与贪心算法解决人力分配问题

1. 问题背景与需求分析

最近在准备华为OD机考时遇到一道关于部门人力分配的算法题，题目场景非常贴近实际开发中的资源规划问题。这道题要求我们在限定时间内完成多个需求开发，同时合理分配固定人力，确保每个月最多处理两个需求且工作量不超负荷。

核心约束条件可以归纳为：

• 有N个需求，每个需求有对应的工作量（人月）
• 必须在M个月内完成所有需求（N/2 ≤ M ≤ N）
• 每个月人力固定且最多完成2个需求
• 每月完成的需求总工作量不超过当月人力
• 目标是找到满足条件的最小人力值

2. 解题思路与算法选择

2.1 问题转化

这本质上是一个在约束条件下寻找最小值的问题。我们需要找到最小的人力值K，使得：

1. 任何单个月份处理的需求工作量总和 ≤ K
2. 每个月最多处理2个需求
3. 所有需求在M个月内完成

2.2 算法选择

这类问题通常适合使用二分查找来解决，因为：

• 人力值K存在明确的范围（最小可能值是最大单个需求，最大可能是所有需求总和）
• 我们可以对给定的K值进行可行性验证
• 二分查找能高效定位最小满足条件的K值

2.3 验证函数设计

关键是如何验证某个K值是否可行：

1. 将需求按从大到小排序（贪心策略）
2. 尝试用双指针法分配需求：
   • 左指针指向最大需求
   • 右指针指向最小需求
   • 如果最大需求+最小需求 ≤ K，则可以配对在一个月完成
   • 否则单独处理最大需求

3. 代码实现与解析

3.1 Java实现

java复制import java.util.Arrays;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        // 示例输入处理
        int M = 3;
        int[] requirements = {3, 5, 3, 4};
        
        System.out.println(minManpower(M, requirements));
    }
    
    public static int minManpower(int M, int[] requirements) {
        // 将需求转为Integer数组以便降序排序
        Integer[] reqs = Arrays.stream(requirements).boxed().toArray(Integer[]::new);
        Arrays.sort(reqs, Collections.reverseOrder());
        
        int left = reqs[0]; // 最小可能值：最大单个需求
        int right = Arrays.stream(requirements).sum(); // 最大可能值：所有需求总和
        
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (canComplete(reqs, M, mid)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
    
    private static boolean canComplete(Integer[] reqs, int M, int K) {
        int months = 0;
        int left = 0, right = reqs.length - 1;
        
        while (left <= right) {
            if (reqs[left] + reqs[right] <= K) {
                left++;
                right--;
            } else {
                left++;
            }
            months++;
        }
        return months <= M;
    }
}

3.2 Python实现

python复制def min_manpower(M, requirements):
    reqs = sorted(requirements, reverse=True)
    left, right = reqs[0], sum(requirements)
    
    def is_possible(K):
        months = 0
        i, j = 0, len(reqs) - 1
        while i <= j:
            if reqs[i] + reqs[j] <= K:
                i += 1
                j -= 1
            else:
                i += 1
            months += 1
        return months <= M
    
    while left < right:
        mid = (left + right) // 2
        if is_possible(mid):
            right = mid
        else:
            left = mid + 1
    return left

# 示例使用
M = 3
requirements = [3, 5, 3, 4]
print(min_manpower(M, requirements))  # 输出6

3.3 C++实现

cpp复制#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

bool canComplete(vector<int>& reqs, int M, int K) {
    int months = 0;
    int left = 0, right = reqs.size() - 1;
    while (left <= right) {
        if (reqs[left] + reqs[right] <= K) {
            left++;
            right--;
        } else {
            left++;
        }
        months++;
    }
    return months <= M;
}

int minManpower(int M, vector<int>& requirements) {
    vector<int> reqs = requirements;
    sort(reqs.rbegin(), reqs.rend());
    
    int left = reqs[0];
    int right = accumulate(reqs.begin(), reqs.end(), 0);
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canComplete(reqs, M, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

int main() {
    int M = 3;
    vector<int> requirements = {3, 5, 3, 4};
    cout << minManpower(M, requirements) << endl; // 输出6
    return 0;
}

4. 算法复杂度分析

4.1 时间复杂度

1. 排序需求数组：O(N log N)
2. 二分查找过程：O(log (sum(reqs)))
3. 每次验证：O(N)
   总体时间复杂度：O(N log N + N log (sum(reqs))) ≈ O(N log N) （当sum(reqs)不是特别大时）

4.2 空间复杂度

1. 需要存储排序后的数组：O(N)
2. 其他变量使用常数空间
   总体空间复杂度：O(N)

5. 边界条件与测试用例

5.1 典型测试用例

python复制# 用例1：刚好满足最小人力
M = 3
requirements = [3, 5, 3, 4]
# 预期输出：6

# 用例2：所有需求都需要单独处理
M = 4
requirements = [7, 8, 9, 10]
# 预期输出：10

# 用例3：可以完美配对
M = 2
requirements = [4, 4, 4, 4]
# 预期输出：8

5.2 边界情况处理

1. 当M = N时（每个需求单独处理）：

   • 最小人力应该是最大单个需求

2. 当M = N/2时（所有需求都能配对）：

   • 最小人力应该是最大配对和

3. 超大需求值：

   • 确保算法能处理requirements[i] ≤ 10^9的情况
   • 使用long类型避免整数溢出

6. 优化与扩展思考

6.1 可能的优化方向

1. 提前终止条件：

   • 如果在验证过程中发现已经超过M个月，可以提前返回false

2. 并行计算：

   • 对于大规模数据，可以将验证过程并行化

6.2 实际应用扩展

1. 动态需求场景：

   • 如果需求是动态增加的，可以考虑在线算法

2. 人力波动情况：

   • 如果每月人力可以变化，问题将变得更加复杂

3. 多资源类型：

   • 考虑开发人员技能差异等更多维度

提示：在实际面试中，除了正确实现算法外，面试官通常还会考察对问题边界条件的考虑、代码的可读性以及时间/空间复杂度的分析能力。建议在练习时养成写注释和测试用例的习惯。

7. 常见错误与调试技巧

7.1 常见错误

1. 排序方向错误：

   • 必须降序排序才能正确应用贪心策略

2. 二分查找边界：

   • 初始left应该是最大单个需求，不是0或1

3. 月份计数错误：

   • 注意while循环的条件和计数位置

7.2 调试技巧

1. 打印中间结果：

   • 在验证函数中打印每月分配情况

2. 小规模测试：

   • 先用小数据验证基本逻辑

3. 边界测试：

   • 专门测试M=N和M=N/2的情况

我在实际编码中发现，最容易出错的是双指针的移动逻辑。一个实用的调试方法是手动模拟一个小例子：

例如requirements = [5,3,3,4], M=3, K=6:

1. 排序后[5,4,3,3]
2. 第一月：5+3=8>6 → 单独做5
3. 第二月：4+3=7>6 → 单独做4
4. 第三月：3
5. 第四月：3 → 超过M=3，所以K=6不可行

这个例子说明初始算法可能存在问题，需要调整验证逻辑。正确的做法应该是：

1. 第一月：5+3=8>6 → 单独做5
2. 第二月：4+3=7>6 → 单独做4
3. 第三月：3+3=6≤6 → 配对完成
   总计3个月，刚好满足

这说明我们需要更精确地计算月份数，不能简单地对每个操作都增加月份计数。