将数组划分为 K 段，使最小值的总和最大化

介绍

假设有一个长度为 n 的整数数组 nums，将其划分为 k 段，每一段的元素个数不一定相等，使得每一段的最小值的总和最大。

例如，数组 nums=[1,2,3,4,5,6,7,8,9,10]，将其划分为 3 段，则最小值的总和最大为 15，划分方式为 [1, 2, 3, 4], [5, 6, 7], [8, 9, 10]。

这是一道比较经典的二分搜索问题，也可以使用动态规划解决。

解法一：二分搜索

对于这个问题，我们可以使用二分搜索来确定最小值的总和。假设最小值的总和为 mid，那么我们可以贪心地从左到右扫描数组，每次尽可能将当前子数组的和加入到一段中，如果超过了 mid，就将当前元素放到下一段中。如果最终得到的段数小于 k，说明 mid 太大了，反之说明 mid 太小了。使用二分搜索可以得到最小值的总和最大的方案。

以下是 Python 代码实现：

def splitArray(nums: List[int], k: int) -> int:
    def check(mid: int) -> bool:
        count = 1
        total = 0
        for num in nums:
            if total + num > mid:
                count += 1
                total = num
                if count > k:
                    return False
            else:
                total += num
        return True

    left, right = max(nums), sum(nums)
    while left < right:
        mid = (left + right) // 2
        if check(mid):
            right = mid
        else:
            left = mid + 1
    return left

解法二：动态规划

同样可以使用动态规划来解决这道问题。设 dp[i][j] 表示将前 i 个数划分为 j 段的最小值总和，那么对于每个 i，我们可以枚举 j 和最后一段的起始位置 k，得到状态转移方程：

dp[i][j] = min(dp[i][j], max(dp[k][j-1], sum(nums[k+1:i+1])))

其中 k < i，j-1 <= k < i。

以下是 Python 代码实现：

def splitArray(nums: List[int], k: int) -> int:
    n = len(nums)
    dp = [[float('inf')] * (k+1) for _ in range(n+1)]
    sub = [0] * (n+1)
    for i in range(1, n+1):
        sub[i] = sub[i-1] + nums[i-1]

    dp[0][0] = 0
    for i in range(1, n+1):
        for j in range(1, k+1):
            for l in range(i):
                dp[i][j] = min(dp[i][j], max(dp[l][j-1], sub[i]-sub[l]))
    return dp[n][k]

总结

本题介绍了两种解法，一种是基于二分搜索的贪心算法，另一种是动态规划。二分搜索的时间复杂度为 $O(n\log(\sum_{i=1}^{n}{nums[i]}))$，动态规划的时间复杂度为 $O(n^3k)$。二分搜索的空间复杂度为 $O(1)$，动态规划的空间复杂度为 $O(nk)$。

参考资料

LeetCode 官方题解