Poj2299 Ultra-QuickSort（另附本质不同逆序对）

Description

给定一个长度为 n(n≤5*10^5) 的序列 a，如果只允许进行比较和交换相邻两个数的操作
求至少需要多少次交换才能把 a 从小到大排序。

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

线段树大法好！

我一个不会离散化的蒟蒻在wa了6遍后终于学会了看题，然后苦逼的发现了999999999才是真正的数据范围

只好向旁边的大佬请教离散化

没想到还挺简单的，很短：

 for(int i=;i<=n;i++)scanf("%d",&x[i].num),x[i].id=i;
         sort(x+,x+n+,cmp);
         for(int i=;i<=n;i++)a[x[i].id]=i;

其实就是把原来的数排序，然后按照大小关系安上新的值。

别看此题说的有多玄学，其实就是逆序对

举个例子吧：

1 2 3 4 5 6 7 8是个有序的数列，假如把3和8调换位置

得到1 2 8 4 5 6 7 3，此时逆序对的个数是5，仔细观察是不是只要5步就可以有序

理性的我讲不出，但是你现在是不是可以感性的理解为什么是逆序对的个数了

所以先离散化处理一下，线段树跑一遍逆序对就行了

代码（long long也是坑点）：

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 int n,m,a[];
 long long ans;
 struct o{int num,id;}x[];
 struct oo{int a,b,v;}s[];
 bool cmp(o a,o b)
 {
     return a.num<b.num;
 }
 void build(int x,int l,int r)
 {
     s[x].a=l,s[x].b=r;s[x].v=;
     if(l==r)return ;
     build(x<<,l,l+r>>);
     build(x<<|,(l+r>>)+,r);
 }
 void change(int x,int y)
 {
     s[x].v++;
     if(s[x].a==s[x].b)return ;
     int mid=s[x].a+s[x].b>>;
     if(y<=mid)change(x<<,y);
     else change(x<<|,y);
 }
 void get(int x,int y)
 {
     if(y>s[x].b)return ;
     if(y<s[x].a)
     {
         ans+=s[x].v;
         return ;
     }
     get(x<<,y);
     get(x<<|,y);
 }
 int main()
 {
     while(scanf("%d",&n))
     {
         if(!n)break;
         ans=;
         build(,,);
         for(int i=;i<=n;i++)scanf("%d",&x[i].num),x[i].id=i;
         sort(x+,x+n+,cmp);
         for(int i=;i<=n;i++)a[x[i].id]=i;
         for(int i=;i<=n;i++)
         {
             change(,a[i]);
             get(,a[i]);
         }
         printf("%lld\n",ans);
     }
 }

被旁边大佬写的树状数组吊锤啊。。呜呜呜！

接下来引进本质不同的逆序对：

Description

给定一个序列a1,a2,…,an，如果存在iaj，那么我们称之为逆序对，求逆序对的数目 

Input

第一行为n,表示序列长度，接下来的n行，第i+1行表示序列中的第i个数。 
N<=10^5。Ai<=10^5

Output

两行，第一行为所有逆序对总数，第二行为本质不同的逆序对总数。 

Sample Input

4
3
2
3
2 

Sample Output

3
1

本质不同的逆序对就是把数列中的多次出现的数都看做只出现了1次（语文被狗吃了），得到的逆序对个数（就是不同的数组成的逆序对个数），希望大家能看懂。

那么怎么处理呢，这个就要考虑离线了（因为你不能知道这个数什么时候首次出现，什么时候最后出现，这样才能确定能以他作为逆序对的范围）

所以我们需要离线处理出来每个数第一次出现位置，和最后一次出现位置

当某个数首次出现把他加入线段树（单点修改），最后一次出现时求出包含该数的逆序对（query）

全部加起来就是答案了

也就是普通的逆序对改一点点

代码如下：

 #include<cstdio>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 void read(int &x) {
     char ch; bool ok;
     for(ok=,ch=getchar(); !isdigit(ch); ch=getchar()) if(ch=='-') ok=;
     for(x=; isdigit(ch); x=x*+ch-'',ch=getchar()); if(ok) x=-x;
 }
 struct oo
 {
     int a,b,num;
 }s[];
 int n,m,d[],used[],f[];long long ans,k,sum;
 void build(int now,int x,int y)
 {
     s[now].a=x,s[now].b=y;
     s[now].num=;
     if(x==y)
         return;
     else
     {
         build(now*,x,x+y>>);
         build(now*+,(x+y>>)+,y);
         s[now].num=s[now<<].num+s[(now<<)+].num;
     }
 }
 void change(int now,int x)
 {
     s[now].num++;
     if(s[now].a==s[now].b)return;
     int mid=s[now].a+s[now].b>>;
     if(x>mid)change(now*+,x);
     else change(now*,x);
 }
 void get(int now,int x)
 {
     if(s[now].b<x)return ;
     if(s[now].a>x)
         ans+=s[now].num;
     else
     {
         if(s[now].a==s[now].b)return ;
         int mid=s[now].a+s[now].b>>;
         get(now*+,x);
         get(now*,x);
     }
 }
 int main()
 {
     read(n);
     for(int i=;i<=n;i++)
     {
         read(d[i]),m=max(m,d[i]);
         if(f[d[i]]==)f[d[i]]=i;
         used[d[i]]=i;
     }
     build(,,m);
     for(int i=;i<=n;i++)
     {
         change(,d[i]);
         get(,d[i]);
     }
     printf("%lld\n",ans);
     ans=;
     build(,,m);
     for(int i=;i<=n;i++)
     {
         if(f[d[i]]==i)change(,d[i]);
         if(used[d[i]]==i)get(,d[i]);
     }
     printf("%lld",ans);
 }