POJ 2299 Ultra-QuickSort (树状数组 && 离散化&&逆序)
题意 : 给出一个数n(n<500,000), 再给出n个数的序列 a1、a2.....an每一个ai的范围是 0~999,999,999 要求出当通过相邻两项交换的方法进行升序排序时需要交换的次数
分析：其实经过一次模拟后，会发现奇妙的东西，这个排序都是按位置排的，最大要求到最大，最小要去到最小，转化思想这是一道求逆序对数的题目，答案就是逆序对数。
这里数据过大999999999，数组无法开的了这么大，我们可以离散化，只记录相对大小。
这里离散化有所不同，这里为了压时，用了空间换时间的方法. 前面的文章有讲到sum(i)表示前面有多少比这个小的数，可以sum(n)-sum(i), 这里有新知识就是sum(i)表示有多少小的数，那当前的总数是i，那大的数就是（i-sum（i）这也是求逆序对的方法，目测挺快的。
1.解释为什么要有离散的这么一个过程？ 刚开始以为999.999.999这么一个数字，对于int存储类型来说是足够了。 还有只有500000个数字，何必要离散化呢？ 刚开始一直想不通，后来明白了，后面在运用树状数组操作的时候， 用到的树状数组C[i]是建立在一个有点像位存储的数组的基础之上的， 不是单纯的建立在输入数组之上。 比如输入一个9 1 0 5 4，那么C[i]树状数组的建立是在， 数据：9 1 0 5 4 p[i].val 编号：1 2 3 4 5 p[i].oder = i************* sort 数据：0 1 4 5 9 编号：3 2 5 4 1 顺序：1 2 3 4 5 a[p[i].编号] = 顺序号;********************** a[3] = 1<--0; a[2] = 2<--1; a[5] = 3<--4; a[4] = 4<--5; a[1] = 5<--9; a[]={ 5 2 1 4 3 } 新号：1 2 3 4 5 值 ： 下标 0 1 2 3 4 5 6 7 8 9 数组 1 1 0 0 1 1 0 0 0 1 现在由于999999999这个数字相对于500000这个数字来说是很大的， 所以如果用数组位存储的话，那么需要999999999的空间来存储输入的数据。 这样是很浪费空间的，题目也是不允许的，所以这里想通过离散化操作， 使得离散化的结果可以更加的密集。 简言之就是开一个大小为这些数的最大值的树状数组 2. 怎么对这个输入的数组进行离散操作？ 离散化是一种常用的技巧，有时数据范围太大，可以用来放缩到我们能处理的范围； 因为其中需排序的数的范围0---999 999 999；显然数组不肯能这么大； 而N的最大范围是500 000；故给出的数一定可以与1.。。。N建立一个一一映射； （1）当然用map可以建立，效率可能低点； （2）这里用一个结构体 struct Node { int val,pos; }p[510000];和一个数组a[510000]; 其中val就是原输入的值，pos是下标； 然后对结构体按val从小到大排序； 此时，val和结构体的下标就是一个一一对应关系， 而且满足原来的大小关系； for(i=1;i<=N;i++) a[p[i].pos]=i; 然后a数组就存储了原来所有的大小信息； 比如 9 1 0 5 4 ------- 离散后aa数组 就是 5 2 1 4 3； 具体的过程可以自己用笔写写就好了。 3. 离散之后，怎么使用离散后的结果数组来进行树状数组操作，计算出逆序数？ 如果数据不是很大， 可以一个个插入到树状数组中， 每插入一个数， 统计比他小的数的个数， 对应的逆序为 i- sum( a[i] ), 其中 i 为当前已经插入的数的个数， sum( a[i] ）为比 a[i] 小的数的个数, i- sum( a[i] ) 即比 a[i] 大的个数， 即逆序的个数 但如果数据比较大，就必须采用离散化方法 假设输入的数组是9 1 0 5 4， 离散后的结果a[] = {5,2,1,4,3}; 在离散结果中间结果的基础上，那么其计算逆序数的过程是这么一个过程。 1.输入5， 调用add(5, 1),把第5位设置为1 1 2 3 4 5 0 0 0 0 1 计算1-5上比5小的数字存在么？ 这里用到了树状数组的sum（5） = 1操作， 现在用输入的下标1 -sum(5) = 0 就可以得到对于5的逆序数为0。 2. 输入2， 调用add(2, 1),把第2位设置为1 1 2 3 4 5 0 1 0 0 1 计算1-2上比2小的数字存在么？ 这里用到了树状数组的sum（2） = 1操作， 现在用输入的下标2 - sum(2) = 1 就可以得到对于2的逆序数为1。 3. 输入1， 调用add(1, 1),把第1位设置为1 1 2 3 4 5 1 1 0 0 1 计算1-1上比1小的数字存在么？ 这里用到了树状数组的sum（1） = 1操作， 现在用输入的下标 3 -sum(1) = 2 就可以得到对于1的逆序数为2。 4. 输入4， 调用add(4, 1),把第5位设置为1 1 2 3 4 5 1 1 0 1 1 计算1-4上比4小的数字存在么？ 这里用到了树状数组的sum（4） = 3操作， 现在用输入的下标4 - sum(4) = 1 就可以得到对于4的逆序数为1。 5. 输入3， 调用add(3, 1),把第3位设置为1 1 2 3 4 5 1 1 1 1 1 计算1-3上比3小的数字存在么？ 这里用到了树状数组的sum（3） = 3操作， 现在用输入的下标5 - sum(3) = 2 就可以得到对于3的逆序数为2。 6. 0+1+2+1+2 = 6 这就是最后的逆序数 分析一下时间复杂度，首先用到快速排序，时间复杂度为O(NlogN), 后面是循环插入每一个数字，每次插入一个数字，分别调用一次add()和sum() 外循环N, add()和sum()时间O(logN) => 时间复杂度还是O(NlogN)
#include <iostream> #include <cstdio> #include <algorithm> using namespace std; typedef long long ll; const int N=5e5+10; struct node{ int val; int pos; }p[N]; int n,bit[N],a[N]; bool cmp(const node&a, const node& b){ return a.val<b.val; } void add(int i){ while(i<=n){ bit[i]+=1; i+=i&-i; } } int sum(int i){ int s=0; while(i>0){ s+=bit[i]; i-=i&-i; } return s; } void solve(){ for(int i=1; i<=n; i++){ scanf("%d",&p[i].val); p[i].pos=i; } sort(p+1,p+n+1,cmp);//排序 for(int i=1; i<=n; i++)a[p[i].pos]=i;//离散化 ll ans=0; for (int i=1; i<=n; i++) bit[i]=0; //初始化树状数组 for(int i=1; i<=n; i++){ add(a[i]); ans+=i-sum(a[i]); } printf("%I64d\n",ans); } int main(){ while(~scanf("%d",&n)&&n){ solve(); } return 0; }
