【算法实战】每日一题：用归并排序去求非逆序对的数量

问题：如何用归并排序去求非逆序对的数量

补充知识

逆序对 | 非逆序对

	逆序对	非逆序对
概念	在一个序列中，如果两个数的先后顺序与它们的大小顺序相反，则这两个数构成一个逆序对。	在一个序列中，如果两个数的先后顺序与它们的大小顺序相同，则这两个数构成一个非逆序对。
例子	序列 [3, 1, 4, 2] 中，3和1，3和2，4和2 都是逆序对。	序列 [1, 2, 3, 4] 中，1和2，1和3，1和4，2和3，2和4，3和4 都是非逆序对。
意义	逆序对的数量可以用来衡量一个序列的混乱程度，是排序算法性能分析的重要指标之一。	非逆序对表示序列已经有序，对于已经排序完成的序列，非逆序对有助于理解其有序性。

求逆序对一般是用归并排序

使用归并排序来求逆序对的最大原因是其合并过程的直观性和效率。在归并排序中，两个已排序的子序列被合并成一个有序序列，这个合并步骤可以让我们准确地计算出两个子序列之间有多少逆序对。

怎么计算

怎么用归并排序去求逆序对的数量

归并排序求逆序对数量的核心思想是利用归并过程中的比较操作来计数。在归并排序的合并步骤中，当我们从右侧有序子数组中选取元素放入结果数组时，左侧剩余的所有元素都自然地与当前选取的元素形成非逆序对。因此，对于每次从右侧数组中选取的元素，它与左侧数组中剩余元素的数量相乘，即为该步骤产生的非逆序对数量。将这个过程中所有步骤的非逆序对数量累加起来，就得到了整个数组的逆序对总数。

当我们从右侧有序子数组中选取元素放入结果数组时，左侧剩余的所有元素都自然地与当前选取的元素形成非逆序对。关于这句话的解释

当我们在归并排序的合并步骤中从右侧有序子数组中选取一个元素放入结果数组时，这个元素会与左侧子数组中的元素进行比较。由于左侧子数组是有序的，且当前从右侧选取的元素比左侧子数组中已比较过的所有元素都要小（否则左侧的元素会被先选取），因此左侧子数组中剩余的任何元素（即尚未与右侧元素进行比较的元素）都会大于或等于当前选取的右侧元素。

由于逆序对的定义是一对元素（a, b），其中 a > b，所以在这种情况下，左侧剩余的每个元素与当前选取的右侧元素都不会构成逆序对，因为它们要么大于或等于这个右侧元素。换句话说，左侧剩余的所有元素与当前选取的右侧元素自然形成了非逆序对（即 a ≤ b）。

在归并排序的合并过程中，每当我们从右侧数组中选取一个元素放入合并数组时，我们可以确定这个元素与左侧数组中所有剩余未处理的元素都不会构成逆序对。因此，我们可以增加逆序对计数器，增加的数量等于左侧数组中剩余元素的数量。这样，随着合并过程的进行，我们能够计算出整个数组的逆序对总数。

简单来说就是：

归并排序中，每次操作都会涉及两个有序序列的合并。如果我们在合并过程中选择了右侧序列的元素，这意味着该元素较小。假设右侧元素的下标是 ( j )。由于左侧序列也是有序的，并且我们选择了右侧的元素，这表明右侧的元素比左侧所有尚未处理的元素都小。

因此，当我们选择右侧数组中的元素时，它与左侧数组中剩余的所有元素形成非逆序对。非逆序对的数量可以通过计算左侧数组剩余元素的数量来确定，即左侧数组的元素总数减去当前下标 ( i ) 再加上 1（因为包括当前正在比较的左侧元素）。这样，我们就可以直接计算出由这次选择产生的非逆序对的数量。

基于上述思路，给出伪代码

归并排序算法的步骤如下：
1. 如果数组的长度小于或等于 1，返回数组本身、0 和数组长度作为非逆序对数和序列长度。
2. 计算数组的中间索引 mid。
3. 对数组的左半部分和右半部分分别进行归并排序，得到排序后的子数组、非逆序对数和序列长度。
4. 初始化两个指针 i 和 j 分别指向左右子数组的起始位置，以及一个计数器 count 用于记录非逆序对数。
5. 当左右子数组的指针都未超出各自子数组的末尾时，进行以下操作：
   a. 如果左子数组当前元素大于等于右子数组当前元素，将右子数组元素添加到合并数组，并增加非逆序对计数器 count（计算方式为左子数组剩余长度减去 i，然后加上之前计算的 count），并将 i 向前移动一位。
   b. 否则，将左子数组当前元素添加到合并数组，并将 i 和 j 都向前移动一位。
6. 将左子数组或右子数组中剩余的元素添加到合并数组中。
7. 计算总的非逆序对数 total_count，为左子数组和右子数组的非逆序对数加上当前步骤计算的 count，并对 MOD 取模。
8. 计算合并后的数组长度 total_length，为左子数组和右子数组长度之和。
9. 返回合并后的数组、总的非逆序对数 total_count 和总长度 total_length。

计算有效裁剪方案数的步骤如下：
1. 初始化一个前缀和数组 prefix_sum，其长度为 n + 1，所有元素初始化为 0。
2. 遍历数组 a，构建前缀和数组。
3. 使用归并排序算法计算数组 a 的非逆序对数。
4. 初始化有效裁剪方案数 valid_schemes 为 0。
5. 遍历数组 a 的所有可能的子数组，计算每个子数组的总和和平均值。
6. 如果子数组的平均值大于等于给定的门票费 t，则增加有效裁剪方案数。
7. 返回有效裁剪方案数。

主函数的步骤如下：
1. 读取输入 n 和 t，分别为元素数量和门票费。
2. 读取数组 a 的所有元素。
3. 调用计算有效裁剪方案数的函数，并输出结果。

程序入口：
如果这是主程序，执行主函数。

CODE

# 定义模数
MOD = 10**9 + 7

# 定义归并排序函数，返回排序数组，非逆序对数，以及序列长度
def merge_sort_and_count(arr):
    """
    归并排序函数，同时计算非逆序对数。
    
    参数:
    arr (list): 输入的待排序数组
    
    返回:
    list: 排序后的数组
    int: 非逆序对数
    int: 序列长度
    """
    if len(arr) <= 1:
        return arr, 0, 1  # 返回排序数组，非逆序对数，以及序列长度

    mid = len(arr) // 2
    # 左数组
    left, left_count, left_length = merge_sort_and_count(arr[:mid])
    # 右数组
    right, right_count, right_length = merge_sort_and_count(arr[mid:])

    # 合并两个有序数组
    merged = []
    i, j, count = 0, 0, 0
    while i < len(left) and j < len(right):
        # 逆序
        if left[i] >= right[j]:
            merged.append(left[i])
            i += 1
            # 计算非逆序对数量
            count += (left_length - i) 
            count %= MOD
        # 非逆序
        else:
            merged.append(right[j])
            j += 1

    # 处理剩余元素
    merged += left[i:]
    merged += right[j:]

    # 计算当前合并后的数组非逆序对数量
    total_count = (left_count + right_count + count) % MOD
    total_length = left_length + right_length

    return merged, total_count, total_length

# 定义计算满足条件的裁剪方案数函数
def count_valid_schemes(n, t, a):
    """
    计算满足条件的裁剪方案数。
    
    参数:
    n (int): 序列长度
    t (int): 门票费
    a (list): 序列
    
    返回:
    int: 满足条件的裁剪方案数
    """
    prefix_sum = [0] * (n + 1)
    for i in range(n):
        prefix_sum[i + 1] = prefix_sum[i] + a[i]

    _, non_inversion_count, _ = merge_sort_and_count(a[:])  # 使用归并排序计算非逆序对数量

    # 计算满足条件的裁剪方案数
    valid_schemes = 0
    for i in range(1, n + 1):
        for j in range(i):
            # 计算裁剪出的序列的总和
            total_sum = prefix_sum[i] - prefix_sum[j]
            # 计算裁剪出的序列的平均值
            avg = total_sum // (i - j)
            # 如果平均值大于等于门票费，则更新方案数
            if avg >= t:
                valid_schemes += 1
                valid_schemes %= MOD

    return valid_schemes

# 主函数
def main():
    """
    主函数，从标准输入读取数据，计算满足条件的裁剪方案数，并输出结果。
    """
    # 示例输入
    n, t = map(int, input().strip().split())
    a = list(map(int, input().strip().split()))

    # 输出结果
    print(count_valid_schemes(n, t, a))

if __name__ == '__main__':
    main();

END