题目描述

给定一个由 n 个正整数组成的数组，你需要将其划分为 k 个非空连续子数组，使得这些子数组的和的最小值最大化。返回可能的最小值

举例：

数组：[ 10, 20, 30, 40 ] ， k = 2。对于此示例，我们可以将它分成两个子数组：

[ 10，20，30 ] 和 [ 40 ]

结果将是 60

解决思路

我们可以使用二分搜索和贪心算法来求解此问题。

首先，我们需要知道最小的可能子数组和应该是什么。我们将所有元素的累计和除以k ，这将会是一个下界。

接下来，我们可以通过二分搜索查找当前可能最大子数组和。

在每个二分步骤中，我们选择一个中间值作为当前划分的可能最大子数组和（可能的解）。我们使用贪心算法来检查当前划分是否满足条件：

• 我们从开始迭代每个元素，将每个元素添加到当前和，直到当前和大于中间值。在这一点上，我们开始新的子数组并保留当前元素的子数组中的最后一个位置。我们继续迭代，这次从刚刚被添加元素的位置开始继续添加。如果我们到达数组末尾，同时也不构成剩余子数组的问题，则表示当前解是可行的。
• 如果我们使用了所有数组元素，并且没有生成足够的子数组，则需要增加中间值，我们再次运行二分搜索操作。相反，如果我们分配了所有元素，并且我们得到了满足条件的划分，则需要减少中间值来查找是否存在更小的可行解。

这个过程最终会收敛到我们的解。 以下是实现解决方案的 Python 代码：

from typing import List


class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        # 贪心算法
        def canSplit(mid: int) -> bool:
            cnt = 1
            curSum = 0
            for num in nums:
                if curSum + num <= mid:
                    curSum += num
                else:
                    cnt += 1
                    curSum = num
                    if cnt > m:
                        return False
            return True

        # 二分搜索
        l, r = max(nums), sum(nums)
        while l < r:
            mid = (l + r) // 2
            if canSplit(mid):
                r = mid
            else:
                l = mid + 1

        return l

时间复杂度：$O(n*logn)$

空间复杂度：$O(1)$

问题扩展

如果更改问题的限制，我们可能需要采取不同的方法，例如：

• 子数组不一定是连续的，如何解决问题？

如果子数组不一定是连续的，则可以使用 DP 来解决问题。我们可以定义 dp[i] 表示将前 i 个元素划分为 j 个非空子数组时最小的划分子数组和。对于每个子数组，我们可以使用另一个指针 k 来操作 dp 数组。

from typing import List


class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        n = len(nums)
        dp = [float('inf')] * (n + 1)
        dp[0] = 0
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                curSum = 0
                for k in range(j - 1, i - 2, -1):
                    curSum += nums[k]
                    dp[j] = min(dp[j], max(dp[k], curSum))
        return dp[n]

• 当 k 不定时，如何解决问题？

当 k 不定时，可以使用上述贪心算法来解决问题，其中我们只需将次数 k 替换为可能的步骤次数。然后我们可以尝试使用二分搜索来查找可行解，并在贪心迭代时重复 上述过程。

from typing import List


class Solution:
    def splitArray(self, nums: List[int], k: int) -> int:
        # 贪心算法
        def canSplit(mid: int) -> bool:
            cnt = 1
            curSum = 0
            for num in nums:
                if curSum + num <= mid:
                    curSum += num
                else:
                    cnt += 1
                    curSum = num
                    if cnt > k:
                        return False
            return True

        # 二分搜索
        l, r = max(nums), sum(nums)
        while l < r:
            mid = (l + r) // 2
            if canSplit(mid):
                r = mid
            else:
                l = mid + 1

        return l