--- sorte de super-rapide inverse

Dans ce problème, vous devez analyser l' algorithme de tri spécifique ---- séquençage ultra-rapide.
L'algorithme de commutation par deux éléments de séquence adjacents pour traiter différents entiers n séquence jusqu'à ce que la séquence dans l' ordre croissant.
Pour une séquence d'entrée de 91 054, en générant un signal de sortie ultra-rapide tri 01.459.
Votre tâche est de déterminer le nombre d' opérations de commutation ultra-rapide pour trier les besoins à effectuer pour une commande de séquence d'entrée donnée.
format d' entrée d'
entrée comprend un certain nombre de cas de test.
La première ligne de chaque nombre entier d'entrée cas de test n, ce qui représente le cas de la longueur de la séquence d'entrée.
Les lignes suivantes de n sont chacun un nombre entier entrent AIAI, l' entrée de données spécifiques de la séquence par le mode de réalisation représentatif, les données représentant le i-ième séquence dans la i-ième ligne.
Lorsque le mode de réalisation d'entrée de séquence d'entrée comprend une longueur de 0, l' entrée est terminée, la nécessité de séquence de processus.
Format de sortie
pour chaque séquence d'entrée à traiter, la sortie d'un op entier, représentant une séquence d'entrée donnée des opérations de commutation nécessaires nombre minimal de tri, de ligne pour chaque nombre entier.
Plage de données
0≤N <5000000≤N <500000,

0≤ai≤9999999990≤ai≤999999999
Exemple d' entrée:
. 5
. 9
. 1
0
. 5
. 4
. 3
. 1
2
. 3
0

Exemple de sortie:
. 6
0

Idée: le nombre deux fois adjacents, le nombre de changement inverse 1 par échange

#include <cstdio>
using namespace std;
typedef long long LL;
const int N = 500010;
int n;
LL q[N], w[N];
LL merge_sort(int l, int r){
 if (l >= r)   return 0;
 int mid = l + r >> 1;
 LL res = merge_sort(l, mid) + merge_sort(mid + 1, r);
 int i = l, j = mid + 1, k = 0;
 while(i <= mid && j <= r)
 if (q[i] < q[j])   w[k ++] = q[i ++];
 else{
  w[k ++] = q[j ++];
  res += mid - i + 1;
 }   
 while(i <= mid)   w[k ++] = q[i ++];
 while(j <= r)     w[k ++] = q[j ++];
  for (i = l, j = 0; i <= r; i ++, j ++)   q[i] = w[j];
 return res;
} 
int main(){
 while(~scanf("%d", &n), n){
  for (int i = 0; i < n; i ++)   scanf("%d", &q[i]);
  printf("%lld\n", merge_sort(0, n - 1));
 }
 return 0;
}