二进制数组中的反转子数组｜豆包MarsCode AI 刷题题解困难题：通过枚举所有子数组并计算每个子数组中的反转对，

题目分析

小R有一个大小为 N 的二进制数组 A，其中每个元素要么是 0，要么是 1。对于数组中的某些元素对 (i, j)，若满足 i < j 且 A[i] > A[j]，则称 (i, j) 形成了一个反转。给定一个整数 K，我们需要计算出数组 A 中所有子数组（连续的部分）中包含恰好 K 个反转的数量。

解题思路

要解决这个问题，我们可以采用以下步骤：

反转对的定义：在一个数组中，反转是指存在一对索引 i 和 j，使得 i < j 且 A[i] > A[j]，即在数组中一个较大的元素出现在了它应该在后的位置。
暴力解法：

对于每一个子数组，我们可以通过两层嵌套循环计算其中的反转对数。遍历所有的子数组，统计每个子数组中的反转对数量，如果等于 K，则计数。

时间复杂度：

对于每个子数组，我们需要计算其中的反转对数量。计算一个子数组的反转对数量需要 O(n^2) 时间，因此总时间复杂度为 O(N^3)，因为我们需要枚举所有的子数组。这样在输入规模较大的时候效率较低。

思路优化：

对于大型输入，可以考虑使用更高效的数据结构，如树状数组或归并排序来优化反转对的计算。这里我们采用简单的暴力解法，后续可以进行优化。

具体实现

count_inversions 函数：用来计算给定数组中反转对的数量。通过两层循环，检查每对元素 A[i] 和 A[j]，如果 i < j 且 A[i] > A[j]，则计为一个反转。
solution 函数：

枚举所有可能的子数组。对每一个子数组，调用 count_inversions 函数来统计反转对的数量。如果该子数组的反转对数量恰好为 K，则累加结果。

代码实现

def solution(N: int, K: int, A: list) -> int:
    # 统计反转对数量的函数
    def count_inversions(arr):
        inv_count = 0
        # 遍历每一个 i, j (i < j)
        for i in range(len(arr)):
            for j in range(i + 1, len(arr)):
                if arr[i] > arr[j]:
                    inv_count += 1
        return inv_count
    
    count = 0
    
    # 枚举所有的子数组
    for start in range(N):
        for end in range(start + 1, N + 1):
            subarray = A[start:end]
            inv_count = count_inversions(subarray)
            if inv_count == K:
                count += 1
                
    return count

# 测试用例
if __name__ == '__main__':
    print(solution(5, 2, [0, 1, 1, 0, 0]) == 3)  # 预期输出: 3
    print(solution(6, 3, [1, 0, 0, 1, 1, 0]) == 0)  # 预期输出: 0
    print(solution(4, 1, [1, 0, 1, 0]) == 4)  # 预期输出: 4

代码解读

count_inversions 函数：

该函数负责计算一个数组中的反转对数量。它通过两层循环遍历数组中的所有 (i, j) 对，如果 i < j 且 A[i] > A[j]，则计为一个反转对。
solution 函数：

使用两层循环来枚举所有的子数组。start 表示子数组的起始索引，end 表示子数组的结束索引。我们通过切片操作 A[start:end] 获得每个子数组。对每个子数组，调用 count_inversions 函数来计算其反转对的数量，并判断是否等于给定的 K。如果相等，计数器 count 增加。

时间复杂度

count_inversions 函数：对于每个子数组，最坏情况下需要 O(n^2) 时间来计算其中的反转对数量。
solution 函数：我们通过两层嵌套的循环枚举所有子数组。对于每个子数组，调用 count_inversions 来计算反转对，因此时间复杂度是 O(N^3)。

优化建议

如果输入规模很大，时间复杂度 O(N^3) 可能会导致超时。可以考虑使用 树状数组 (Fenwick Tree) 或 归并排序 等方法来优化反转对的计算，减少时间复杂度至 O(N log N) 或 O(N^2)。

二进制数组中的反转子数组 ｜ 豆包MarsCode AI 刷题