In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,
Ultra-QuickSort produces the output
0 1 4 5 9 .
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.
Input
The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.
Output
For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.
Sample Input
5
9
1
0
5
4
3
1
2
3
0
Sample Output
6
0题目大意：给你一个序列，你只能移动相邻的两个数，使得最终得到的序列是从小到大的顺序排列的，求最小的移动次数
变相的求逆序数，可以用树状数组来操作求逆序数（在第一个样例中是 1,0 5,4 9,1 9,0 9,5 9,4），由于树状数组是通过二进制来操作实现的,没有办法存储所给的数据，所以需要离散化
#include<iostream>
#include<cstring>
#include <algorithm>
using namespace std;
const int mod =1e9+7;
typedef long long ll;
ll n;
ll c[500010];
ll a[500010];//a[i]的范围太大，放不进c数组，因此需要离散化
struct node
{
int val;//存储原来的数值
int id;//存储下标
bool operator < (const node &a) const
{
return val < a.val;
}
}num[500010];
int lowbit(int a)
{
return a&-a;
}
void add(int x)
{
while(x<=n)
{
c[x]+=1;
x+=lowbit(x);
}
}
int sum(int x)
{
int res=0;
while(x>0)
{
res+=c[x];
x-=lowbit(x);
}
return res;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
while(cin>>n&&n)
{
memset(a,0,sizeof a);
memset(c,0,sizeof c);
memset(num,0,sizeof num);
for(int i=1;i<=n;i++)
cin>>num[i].val,num[i].id=i;
sort(num+1,num+1+n);//先排一下顺序，从小到大排，为离散做准备
// for(int i=1;i<=n;i++)
// cout<<num[i].val<<" ";
for(int i=1;i<=n;i++)//开始离散
a[num[i].id]=i;//因为输入的数据是没有重复的，因此可以将其数据范围缩小
ll ans=0;//为什么离散之后还是能够保证答案的正确性呢？因为我们要看逆序数有多少，只要知道
//它们的排列大小顺序就行，而不用管到底是多大的数，比如100000 1 2和10 1 2不是一个意思吗，都含
//一个逆序数，然后下面的步骤就是建立树状数组，只用a数组就可以了
for(int i=1;i<=n;i++)
{
add(a[i]);//每次都树状数组赋值，因为树状数组是向后更替的，如果输入的数越小，遍历+1的就 //越多,如果前三个都比第四个小，那么在i-sum(a[i])就是0
ans+=i-sum(a[i]);//sum(a[i])是求前面比a[i]小的个数，i-sum(a[i])就是求比a[i]大的
//个数
}
cout<<ans<<endl;
}
return 0;
}
其实这个数状数组就是一种特殊排列的一种数组，其本质还是数组，只不过我们把它模拟成一种树的形状而已，要时刻明白它的二级制的转换求其add与sum模板函数的意思。一个参考详细的传送