逆序数 POJ 2299 Ultra-QuickSort

题目传送门

 /*
     题意：就是要求冒泡排序的交换次数。
     逆序数：在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。
     一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列；逆序数为奇数的排列称为奇排列。
     如2431中，21，43，41，31是逆序，逆序数是4，为偶排列。也是就说，对于n个不同的元素，
     先规定各元素之间有一个标准次序（例如n个 不同的自然数，可规定从小到大为标准次序），于是在这n个元素的任一排列中，
     当某两个元素的先后次序与标准次序不同时，就说有1个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。

     接下来有多种做法求解逆序数：1. 暴力；2. 归并排序；3. 线段树-单点更新；4. 树状数组
 */

 /*
     暴力 超时 O(n^2)
 */
 #include <stdio.h>

 const int MAX_N = ;
 int a[MAX_N+];
 long long cnt = ;

 int main(void)        //POJ 2299 Ultra-QuickSort
 {
     //freopen ("inD.txt", "r", stdin);
     int n;

     while (scanf ("%d", &n) != EOF && n)
     {
         for (int i=; i<=n; ++i)
         {
             scanf ("%d", &a[i]);
         }

         for (int i=; i<=n; ++i)
         {
             for (int j=i+; j<=n; ++j)
             {
                 if (a[i] > a[j])
                     cnt++;
             }
         }
         printf ("%lld\n", cnt);
         cnt = ;
     }

     return ;
 }

暴力 超时 O(n^2)

 /*
     归并排序是将数列a[p, r]分成两半a[p, q]和a[q+1,r]分别进行归并排序，
     然后再将这两半合并起来。在合并的过程中（设p<=i<=q，q+1<=j<=r），
     当L[i]<=R[j]时，并不产生逆序数；
     当L[i]>R[j]时，在前半部分中比L[i]大的数都比R[j]大，
     将R[j]放在L[i]前面的话，逆序数要加上q+1-i。
     因此，可以在归并排序中的合并过程中计算逆序数。 

     这道题充分印证了，即使merge本身可能用的不多，但分冶的思想却是无所不在:)
 */
 #include <stdio.h>

 const int MAX_N = ;
 const int INF = 0xffffff;
 int a[MAX_N+];
 long long cnt = ;

 void Merge(int *a, int p, int q, int r)
 {
     int n1 = q - p + ;
     int n2 = r - q;
     int L[MAX_N/+], R[MAX_N/+];
     int i, j;
     for (i=; i<=n1; ++i)    L[i] = a[p+i-];
     for (j=; j<=n2; ++j)    R[j] = a[q+j];
     L[n1+] = INF;    R[n2+] = INF;

     i = ;    j = ;
     for (int k=p; k<=r; ++k)
     {
         if (L[i] <= R[j])
         {
             a[k] = L[i++];
         }
         else
         {
             a[k] = R[j++];
             cnt += n1 - i + ;         //此步骤是在归并排序法中加的一句，用来计数求逆序数的数目
         }
     }
 }

 void MergeSort(int *a, int p, int r)
 {
     int q;
     if (p < r)
     {
         q = (p + r) / ;
         MergeSort (a, p, q);
         MergeSort (a, q+, r);
         Merge (a, p, q, r);
     }
 }

 int main(void)        //POJ 2299 Ultra-QuickSort
 {
     //freopen ("inD.txt", "r", stdin);
     int n;

     while (scanf ("%d", &n) != EOF && n)
     {
         for (int i=; i<=n; ++i)
         {
             scanf ("%d", &a[i]);
         }
         MergeSort (a, , n);
         printf ("%lld\n", cnt);
         cnt = ;
     }

     return ;
 }

归并排序

 /*
     线段树-单点更新
 */
 #include <cstdio>
 #include <algorithm>
 #define lson l, m, rt << 1
 #define rson m+1, r, rt << 1 | 1
 using namespace std;

 const int MAX_N = ;
 const int INF = 0x3f3f3f3f;
 int a[MAX_N];
 int b[MAX_N];
 int sum[MAX_N << ];

 void pushup(int rt)
 {
     sum[rt] = sum[rt << ] + sum[rt <<  | ];
 }

 void build(int l, int r, int rt)
 {
     sum[rt] = ;
     if (l == r) return ;
     int m = (l + r) >> ;
     build (lson);
     build (rson);

     pushup (rt);
 }

 void update(int p, int l, int r, int rt)
 {
     if (l == r)
     {
         sum[rt]++;      //记录次数
         return ;
     }
     int m = (l + r) >> ;
     if (p <= m)
     {
         update (p, lson);
     }
     else
         update(p, rson);
     pushup (rt);
 }

 int query(int ql, int qr, int l, int r, int rt)
 {
     if (ql <= l && r <= qr)
     {
         return sum[rt];
     }
     int m = (l + r) >> ;
     int ans = ;
     if (ql <= m)    ans += query (ql, qr, lson);
     if (qr > m)     ans += query (ql, qr, rson);

     return ans;
 }

 int BinarySearch(int key, int l, int r)
 {
     while (r >= l)
     {
         int mid = (l + r) >> ;
         if (key == b[mid])    return mid;
         if (key < b[mid])    r = mid - ;
         else    l = mid + ;
     }
 }

 int main(void)
 {
     //freopen ("inD.txt", "r", stdin);
     int n;
     while (~scanf ("%d", &n) && n)
     {
         build (, n-, );

         for (int i=; i<=n; ++i)
         {
             scanf ("%d", &a[i]);
             b[i] = a[i];
         }
         sort (b+, b+n+);
         long long ans = ;
         for (int i=; i<=n; ++i)
         {
             int x = BinarySearch (a[i], , n);
             ans += query (x, n, , n, );
             update (x, , n, );
         }
         printf ("%lld\n", ans);
     }

     return ;
 }

线段树-单点更新