优点：复杂度 

缺点：存在大量拷贝，增加了时间成本；代码不如用树状数组简单。 

(3）树状数组与逆序对

用树状数组求逆序对，是树状数组的巧妙应用，比其他方法都好。

用树状数组解逆序对：把数字看成树状数组的下标。
例如序列{5,4,2,6,3,1}，对应a[5]、a[4]、a[2]、a[6]、a[3]、a[1]。
每处理一个数字，树状数组的下标所对应的元素数值加一，统计前缀和，就是逆序对的数量。
①倒序
用树状数组倒序处理数列，当前数字的前一个数的前缀和即为以该数为较大数的逆序对的个数。

例如{5,4,2,6,3,1}，倒序处理数字:

• 数字1。把a[1]加一，计算a1l前面的前缀和sum(0)，逆序对数量ans = ans + sum(0)=0
• 数字3。把a[3]加一，计算a[3]前面的前缀和sum(2)，逆序对数量ans = ans + sum(2)=1;
• 数字6。把a[6]加一，计算a[6]前面的前缀和sum(5)，逆序对数量ans = ans + sum(5)=1+2=3;
• 等等.....

复杂度：处理n个数字，每个数字有加一add()和求前缀和sum()操作（都是logn）,所以总复杂度为O(nlogn)

②正序（虽然正序比较难，但也可能需要用到，例如下面例题）
当前已经处理的数字个数减掉当前数字的前缀和即为以该数为较小数的逆序对个数。

例如{5,4,2,6,3,1}，正序处理数字:

• 数字5。把a[5]加一，当前处理了1个数，ans = ans + ( 1-sum(5))=0;
• 数字4。把a[4]加一，当前处理了2个数，ans = ans +(2-sum(4))=0+1= 1;·
• 数字2。把a[2j加一，ans = ans + (3-sum(2))=1+2= 3;
• 数字6。把a[6]加一，ans = ans + (4-sum(6))=3+0= 3;
• 等等。。。。  

离散化

        上面的处理方法“把数字看成树状数组的下标”有个问题，如果数字比较大，例如数字等于，那么树状数组的空间也要开到= 1G，远远超过了题目限制的空间。
        用“离散化”这个小技巧能解决这个问题。 

• 离散化：把原来的数字，用它们的相对大小来替换原来的数值，而它们的顺序仍然不变。
• 例:{1,20543,19,376,546007640}，它们的相对大小是{1,4,2,3,5}。
• 有多少个数字，离散化后的每个数字的大小就是多大。
• 在用树状数组求解逆序对的题目中，离散化几乎是必须的。
• 本题需处理500000个数字，离散化之后树状数组大小只需500000。

离散化方法1：重复数字离散化后不一样

a = [1，20543，19，376，546007640,19]
print(a)
b = sorted(a)
print(b)
for i in range (len(b)):k = a.index(b[i])a[k] = i+1    #a[a.index(b[i])]= i+1
print(a) # [1，5，2，4, 6，3]

离散化方法2：重复数字离散化后也一样

def discretization(h):b = list (set (h))    # 用集合去重b. sort()for i in range (len(h)) :h[i] = b.index(h[i])+1
a = [1，20543，19，376，546007640,19]
print(a)
discretization(a)    # 列表可以在函数中完成修改且不需要return
print (a) # [1，4，2，3，5，2]

【代码】：

# 数组树状标准模板
def lowbit(x):return x & -x
def update(x, d):while x <= n:tree[x] += dx += lowbit(x)
def sum(x):ans = 0while(x > 0):ans += tree[x] x -= lowbit(x)return ansn = int(input())
a = [0]+list(map(int,input ().split()))#从a[1]开始
# 离散化
b = sorted(a)
for i in range(n+1) : a[a.index (b[i])] = i+1tree = [0]*(n+1)
res = 0
for i in range(len(a)-1, 0, -1):update(a[i], 1)res += sum(a[i]-1)
print (res)

例题：小朋友排队

题目描述

n个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。

每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是 0。

如果某个小朋友第一次被要求交换，则他的不高兴程度增加 1，如果第二次要求他交换，则他的不高兴程度增加 2（即不高兴程度为 3），依次类推。当要求某个小朋友第 k 次交换时，他的不高兴程度增加 k。

请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。

如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。

输入描述

输入的第一行包含一个整数 n，表示小朋友的个数。

第二行包含 n 个整数 H1​H2​...Hn​，分别表示每个小朋友的身高。

其中，。

输出描述

输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。

输入输出样例

输入

3
3 2 1

输出

9

思路： 

• 每个小朋友要交换多少次﹖

每一个小朋友最少的交换次数等于他左边比他高的人数加上右边比他矮的人数。

• 逆序对问题，包括2个逆序对:

        (1）他左边比他高的人; 

        (2）右边比他矮的人。

• 用树状数组做两次逆序对，一次正序处理，一次倒序处理。

【代码】 

N = 100010
def discret(sl: list):      #树状数组离散化（离散化方法2：重复数字离散化后也一样）hl = sorted(set(sl))for i in range(len(sl)):sl[i] = hl.index(sl[i]) + 1tree = [0] * N
def lowbit(x):return x & (-x)
def tree_add(x, d):while x <= N:tree[x] += dx += lowbit(x)
def tree_sum(x):ans = 0while x > 0:ans += tree[x]x -= lowbit(x)return ansn = int(input())
a = list(map(int, input().split()))     
discret(a)                              #对n个小朋友的身高进行离散化(究竟是什么样的小朋友身高会是1e6)
a = [0] + a#每个人交换次数=前面比他高的人数+后面比他矮的人数
excnt = [0] * N                         #记录n个小朋友每人交换的次数，0不用
for i in range(1, n + 1):               #正向统计，可以计算出a[i]前面比a[i]高的人数tree_add(a[i], 1)excnt[i] = i - tree_sum(a[i])tree = [0] * N                          #重新初始化tree数组
for i in range(n, 0, -1):               #逆向统计，可以计算出a[i]后面比a[i]矮的人数tree_add(a[i], 1)excnt[i] += tree_sum(a[i] - 1)      #统计和res = 0
for i in range(1, n + 1):               #统计总的不高兴值res += excnt[i] * (1 + excnt[i]) // 2   #n次交换，不高兴值是1+2+3+...+n
print(res)