构造可被 K 整除的大小为 N 数组，并使最大值最小化

为了构造一个大小为 N 的数组，其总和可被 K 整除，并且数组最大值最小化，我们需要采取一些策略来将问题分解为更小的子问题并解决它们。

分解问题

首先，我们需要将问题分解为两个子问题：

1. 构造一个大小为 N，其总和可被 K 整除的数组
2. 使数组最大值最小化

通过解决这两个子问题，我们可以创建我们需要的数组。

解决第一个子问题

在这一步中，我们需要找到一个大小为 N 的数组，其总和可被 K 整除。我们可以通过以下方法实现：

1. 创建一个初始大小为 N 的全零数组 A
2. 计算数组 A 中所有元素之和 s
3. 计算 k 的模数 r：r = s mod k
4. 如果 r = 0，那么我们已经完成了！数组 A 的总和可以被 K 整除
5. 如果 r ≠ 0，我们需要增加某些数字以使其可被 K 整除。
   • 首先，我们需要找到一个最小的数字 d，它满足：d mod k = r
   • 然后，我们将 A 中的一个元素增加 d。我们选择增加一个较小的元素，这样才能确保最大值最小化。
   • 重新计算数组 A 中所有元素之和 s 和 k 的模数 r，并重复步骤 5，直到 r = 0

这个算法的时间复杂度为 O(N)。

解决第二个子问题

在第一步中，我们已经创建了一个大小为 N 的数组，其总和可被 K 整除。现在我们需要使数组的最大值最小化。

为此，我们可以使用二分搜索算法，该算法的时间复杂度为 O(log max(A))，其中 max(A) 表示数组 A 的最大值。

具体而言，我们的算法应该如下所示：

1. 将数组的最小值初始化为 0，最大值初始化为 s/k
2. 算法的目标是找到一个最小的 mid 值使得切分后的子数组会较小。
   • mid 值需要在区间 [lo, hi) 之间搜索，其中 lo 是最小值，hi 是最大值
3. 对于每个 mid 值，我们都要检查是否有办法将数组分成 k 个部分，且每个部分的总和都小于等于 mid 值
   • 为了做到这一点，我们需要从左到右遍历数组 A 并且在遇到新的部分时更新当前部分装入的数字之和
   • 如果我们发现当前部分装入的数字之和超过 mid 值，则我们需要增加部分数量并将下一个数字作为新的部分的第一个数字
4. 如果我们找到一个 mid 值使得所有部分都合法且总数 <= k，则我们需要减小最大值并继续搜索更小的 mid 值
5. 如果我们找到一个 mid 值使其不能构成 k 个 <= mid 的子数组，则我们需要增加最小值并继续搜索更大的 mid 值
6. 当找到最小的 mid 值使得所有部分都合法且总数 <= k 时，我们就得到了最小化最大值的解决方案

完整算法

基于上述内容，我们可以设计一个完整的解决方案。

def construct_array(N, K):
    A = [0] * N
    s = sum(A)
    r = s % K
    while r != 0:
        d = next_divisible(r, K)
        i = A.index(min(filter(lambda x: x % K == d, A)))
        A[i] += d
        s = sum(A)
        r = s % K

    lo, hi = 0, s // K
    while lo < hi:
        mid = (lo + hi) // 2
        if check(mid, A, K):
            hi = mid
        else:
            lo = mid + 1

    return A


def next_divisible(n, k):
    return (k - n) % k

def check(mid, A, K):
    parts = 0
    curr_part_sum = 0
    for num in A:
        curr_part_sum += num
        if curr_part_sum > mid:
            parts += 1
            curr_part_sum = num
        if parts >= K:
            return False
    return True

结论

在这个算法中，我们首先通过增加数字来确保数组的总和可被 K 整除。然后，我们使用二分搜索来找到最小的 mid 值使得所有部分都合法，且总数 <= K。最后，我们返回数组本身。

这个算法的时间复杂度为 O(N log N)。