最大化相等元素的子数组长度

给定一个长度为 n 的数组 nums，最多执行 k 次将一个元素增加 1，求最长的子数组，使得该子数组中所有元素相等。

思路

通过对数组遍历，将数组中每个元素与前一个元素的差值存入一个另外的数组 diff 中，然后对 diff 数组排序。我们始终贪心地选择 diff 数组中的前 k 大的数进行加一操作，这样能够保证在最多执行 k 次加一操作的情况下，相等元素的子数组最长。

具体实现过程如下：

1. 计算 diff 数组

n = len(nums)
diff = [nums[i] - nums[i-1] for i in range(1, n)]

2. 排序 diff 数组

diff.sort(reverse=True)

3. 计算前 k 大的差值之和

sum_diff_k = sum(diff[:k])

4. 判断是否能使子数组长度延长

if sum_diff_k + k - 1 <= max_len:
    return max_len + sum_diff_k // k
else:
    return max_len + k

其中 max_len 表示当前已经求出的最大子数组长度。如果选择加一操作使得子数组长度延长，那么加一后的元素需要与前一个元素相等，因此加一次后 max_len 的值需要除以 k 再加上 1。

代码实现

完整的 Python 代码实现如下：

from typing import List

def max_equal_subarray(nums: List[int], k: int) -> int:
    n = len(nums)
    if n == 1:
        return 1

    diff = [nums[i] - nums[i-1] for i in range(1, n)]
    diff.sort(reverse=True)

    max_len = 1
    sum_diff_k = 0
    for i in range(k):
        if i < len(diff):
            sum_diff_k += diff[i]
        else:
            break

        if sum_diff_k + i + 1 <= max_len:
            break
        else:
            max_len = max(max_len, sum_diff_k // (i + 1) + 1)

    if sum_diff_k + k - 1 <= max_len:
        return max_len + sum_diff_k // k
    else:
        return max_len + k

性能分析

时间复杂度：排序操作 O(nlogn)，O(k) 次加一操作，因此时间复杂度为 O(nlogn + k)。如果 k 比较小的话，也可以将 diff 数组全部排序，然后取前 k 大的元素。（复杂度变为 O(nlogn)）

空间复杂度：O(n)，需要一个 diff 数组来存储相邻元素的差值。