题目描述

给定一个只包含 0 和 1 的数列，你可以进行最多 K 次操作，每次操作可以将一个 0 翻转成 1，要求翻转后的数列中任意两个相邻的 1 之间至少间隔 K 个 0。

请计算在最多 K 次操作的情况下，最多能在数列中得到多少个相邻的 1。

解题思路

一个显然的思路是按照贪心的策略，将所有相邻的 1 之间尽量填满 K 个 0。具体实现时，可以维护一个指针 $l$，代表当前处理到的左边端点，同时维护一个可操作次数 $k$。对于指针 $l$，向右边扫描，扫描到第一个 1 时，寻找到 $l$ 到这个 1 之间的所有 0，判断这段 0 的长度是否大于等于 K，如果是，就将 $l$ 移到这段 0 的后面一个位置，并将这段 0 的第 K 个位置翻转成 1；如果不是，将这段 0 全部翻转成 1，将 $k$ 减去这段 0 的长度减 1，因为翻转成 1 的那个位置周围最多只能够填 1 个 0。在进行完这个操作后，将指针 $l$ 指向翻转成 1 的位置，继续向右扫描。

在扫描过程中，需要特别处理 $l$ 到数列结尾的情况，这可以通过在数列最后插入 K 个 0 实现。

时间复杂度为 $O(n)$，其中 $n$ 为数列长度。

代码示例

def max_adjacent_ones(nums: List[int], k: int) -> int:
    n = len(nums)
    l, res = 0, 0
    
    nums.extend([0] * k)
    k += 1
    
    while l < n:
        if nums[l] == 0:
            cnt = 0
            while l < n and nums[l] == 0:
                l += 1
                cnt += 1
            if cnt >= k:
                res += cnt // k
                k = 1
            else:
                k -= cnt
            continue
        r = l
        while r < n and nums[r] == 1:
            r += 1
        if r == n:
            res += (n - l) // k
            break
        dis = r - l
        if dis >= k:
            res += 1
            k = 1
        else:
            res += 1
            k -= dis
        l = r
    
    return res

其中，nums 是输入的数列，k 是可以进行的翻转次数。函数返回最多能够得到的有几个相邻的 1。