uva 10810 - Ultra-QuickSort

题意为，给你一个序列， 每次交换两个相邻的数使序列为递增的序列， 求最小的交换次数。

 

首先我们可以看出。 最少的交换次数肯定得用归并排序来求了。

实际上归并排序的交换次数就是这个数组的逆序对个数，为什么呢？

我们可以这样考虑：

归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。

在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在

前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并

排序中的合并过程中计算逆序数.

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <cctype>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MAXN 500000+10
#define INF (1<<30)
#define mod 123456789
int a[MAXN];
int tem[MAXN];
LL total = 0;
int Merge_sort(int l, int r){
    int mid = (l+r)>>1;
    int x = l, y = mid+1;
    int ans = 0;
    while(x <= mid && y <= r){
        if(a[x] > a[y]){
            tem[ans++] = a[y];
            y++;
            total += mid-x+1;
        }
        else {
            tem[ans++] = a[x];
            x++;
        }
    }
    while(x <= mid) tem[ans++] = a[x++];
    while(y <= r)   tem[ans++] = a[y++];
    ans = 0;
    for(int i = l; i <= r; i++)
        a[i] = tem[ans++];
}
int Merge(int l,int r){
    if(l < r){
        int mid = (l+r)>>1;
        Merge(l,mid);
        Merge(mid+1,r);
        Merge_sort(l,r);
    }
}
int main (){
    int n;
    while(scanf("%d",&n) != EOF && n){
        total = 0;
        for(int i = 0; i < n; i++){
            scanf("%d",&a[i]);
        }
        Merge(0,n-1);
        cout << total << endl;
    }
    return 0;
}

来源

目前求逆序对数目比较普遍的方法是利用归并排序做到的时间复杂度。 当然，也可以利用树状数组、线段树来实现这种基础功能。复杂度均为。

#include <stdio.h>
#define inf 2000000000
#define sz 500005

void mergesort(int p, int r);
void merge(int p, int q, int r);
int a[sz], L[(sz/2)+5], R[(sz/2)+5];
long long int cnt;

int main()
{
    int n, i;
    while(scanf("%d", &n) && n)
    {
        for(i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        cnt = 0;
        mergesort(1, n);
        printf("%lld\n", cnt);
    }
    return 0;
}

void mergesort(int p, int r)
{
    if(p < r)
    {
        int q;
        q = (p+r)/2;
        mergesort(p, q);
        mergesort(q+1, r);
        merge(p, q, r);
    }
    return ;
}

void merge(int p, int q, int r)
{
    int ind1, ind2, k, i, j;
    for(i = p, ind1 = 1; i <= q; i++)
        L[ind1++] = a[i];
    L[ind1] = inf;
    for(i = q + 1, ind2 = 1; i <= r; i++)
        R[ind2++] = a[i];
    R[ind2] = inf;
    i = j = 1;
    for(k = p; k <= r; k++)
    {
        if(L[i] > R[j])
        {
            cnt += ind1 - i;
            a[k] = R[j];
            j++;
        }
        else
        {
            a[k] = L[i];
            i++;
        }
    }
    return ;
}

 

/*
 *  Problem : "Ultra-QuickSort"
 *  ID      : 10810
 *  Date    : 2011-03-15
 *  Idea    : 這題可以學到很多東西，雖然題目是叫 Quick Sort ，但是它卻要求我們要記錄 swap 的次數，
 *            因此第一時間想到的就是 10327 題的 Flip Sort （即 Bubble Sort），不過這題是其進階版，
 *            最大的問題就是要克服 TLE 的問題（ O(n^2) 一定會超過 3 秒），所以我們從 Merge Sort 下手
 *            然後發現 Merge Sort 其 Left Array & Right Array 之間其實存在一個很奇妙的關係，要記錄
 *            Swap 次數是要在 L > R 的時候才需要，而且公式就是 n1 - i + 1（可在紙上演練一下）。
 *
 *            另外要注意一下就是 count 可能 overflow ，記得 long long !
 *  Author  : EragonJ
 */
#include <iostream>
#define MAX 502000
using namespace std;

long long int count = 0;

void merge(int A[], int p, int q, int r) {
  extern long long int count;

  int n1 = q - p + 1;
  int n2 = r - q;

  int* L = (int*) malloc((n1 + 1) * sizeof(int));
  int* R = (int*) malloc((n2 + 1) * sizeof(int));

  for (int i = 1; i <= n1; i++) {
    L[i] = A[p + i - 1];
  }

  for (int i = 1; i <= n2; i++) {
    R[i] = A[q + i];
  }

  int i, j, k;
  for (k = p, i = 1, j = 1; (k <= r) && (i <= n1) && (j <= n2); k++) {
    if (L[i] <= R[j]) {
      A[k] = L[i];
      i++;
    }
    else {
      A[k] = R[j];
      j++;
      count += (n1 - i + 1); // Important formula
    }
  }

  for (i; i <= n1; i++) {
    A[k++] = L[i]; 
  }

  for (j; j <= n2; j++) {
    A[k++] = R[j];
  }
}

void merge_sort(int A[], int p, int r) {
  if (p < r) {
    int q = (p + r) / 2;
    merge_sort(A, p, q); 
    merge_sort(A, q + 1, r);
    merge(A, p, q, r);
  }
}

int main() {

  int n;
  int input[MAX] = {0};
  while (scanf("%d", &n) == 1) {
    if (n == 0) {
      break;
    }

    for (int i = 0; i < n; i++) {
      // Index range : 1 ~ n;
      scanf("%d", &input[i + 1]);
    }

    merge_sort(input, 1, n);

    extern long long int count;
    cout << count << endl;

    count = 0;
  }

  return 0;
}

 

解题方法：离散化+树状数组

 

/*题目大意：给出一个序列，每次交换两个数，这两个数之间的距离就是代价，问说要将序列排序的总代价是多少。
解题思路:归并排序下的逆序数的个数。*/
#include <stdio.h>
#include <string.h>

const int N = 500005;
typedef long long ll;
int n, g[N], f[N];

ll Msort(int l, int r, int* a, int* b) {
    if (r - l == 1) return 0;

    int m = (l + r) / 2;
    ll ans = Msort(l, m, a, b) + Msort(m, r, a, b);
    int p = l, q = m, c = l;
    while (p < m || q < r) {
        if (q >= r || (p < m &&  a[p] <= a[q])) b[c++] = a[p++];
        else {
            ans += m - p;
            b[c++] = a[q++];
        }
    }
    for (int i = l; i < r; i++) a[i] = b[i];
    return ans;
}

int main() {
    while (scanf("%d", &n) == 1 && n) {
        for (int i = 0; i < n; i++) scanf("%d", &g[i]);
        printf("%lld\n", Msort(0, n, g, f));
    }
    return 0;
}