国际空间研究组织 | ISRO CS 2009 |问题 59

该问题是一道编程问题，需要求解一个数学方程。

问题描述

给定一个长为N的数组A[]，请计算在数组A[]中有多少对(i, j)满足0≤i < j≤N−1且A[i]> A[j]。

输入格式

第一行为数组元素个数N。第二行为数组A[]中的N个整数。

输出格式

输出仅包含一个整数，即在数组A[]中有多少对(i, j)满足0≤i < j≤N−1且A[i]> A[j]。

示例输入

5
2 4 1 3 5

示例输出

3

问题分析

这是一道非常经典的计数问题，通常被称为逆序对问题。最朴素的方法就是对于每一个数，遍历其后面的所有数，看有多少个数小于它，但这样复杂度为O(N^2)，显然无法通过本题。有两种更为高效的解法：

解法一：归并排序

归并排序在排序的同时即可统计逆序对个数。具体原理是这样的：在合并两个有序数组A和B时，如果当前处理的A数组元素a大于B数组元素b，那么a比B数组中所有元素都大，可以得到逆序对数+len(B)，其中len(B)为B数组当前剩余元素数量。

时间复杂度O(N logN)

代码片段：

def merge_sort(arr, l, r):
    if l == r:  # 递归边界
        return 0
    mid = l + r >> 1  # 分治分界点
    cnt = merge_sort(arr, l, mid) + merge_sort(arr, mid + 1, r)  # 计算贡献
    i, j = l, mid + 1
    tmp = []
    while i <= mid and j <= r:  # 将两段有序数组合并，计算贡献
        if arr[i] <= arr[j]:
            tmp.append(arr[i])
            i += 1
        else:
            tmp.append(arr[j])
            j += 1
            cnt += mid - i + 1  # 注意此处计算贡献
    while i <= mid:
        tmp.append(arr[i])
        i += 1
    while j <= r:
        tmp.append(arr[j])
        j += 1
    arr[l:r + 1] = tmp[:]  # 拷贝回原数组
    return cnt

n = int(input())
a = [int(x) for x in input().split()]
print(merge_sort(a, 0, n - 1))

解法二：树状数组/线段树

利用树状数组或线段树，可以高效计算区间内逆序对个数。算法流程为遍历数组A，并将每个A[i]作为区间右端点，求出0~A[i]的逆序对个数。

时间复杂度O(N logN)

代码片段：

class BIT:
    def __init__(self, n):
        self.n = n
        self.c = [0] * n

    def lowbit(self, x):
        return x & -x

    def update(self, p, v):
        while p <= self.n:
            self.c[p] += v
            p += self.lowbit(p)

    def query(self, p):
        res = 0
        while p:
            res += self.c[p]
            p -= self.lowbit(p)
        return res

n = int(input())
a = [int(x) for x in input().split()]

num = list(set(a))  # 离散化
num.sort()
num = {num[i]: i + 1 for i in range(len(num))}

ans = 0
bit = BIT(n)
for i in range(n - 1, -1, -1):
    ans += bit.query(num[a[i]] - 1)
    bit.update(num[a[i]], 1)
print(ans)

总结

本题是一道经典的计数问题，可以用归并排序或树状数组/线段树高效解决。归并排序更为简单，但需要拥有排序的能力，具体来说就是要知道“将两段有序数组合并”这个操作。树状数组/线段树同样高效，但更为复杂，需要熟悉树状数组/线段树的基本操作。