In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,
Ultra-QuickSort produces the output
0 1 4 5 9 .
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.
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
树状数组模板题。
思路：看此篇博文之前，你要对树状数组有所了解，这里树状数组求的也是和，并且因为更新多次，所以不用树状数组减少复杂度的话铁定超时。
树状数组主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以
在log(n)的复杂度下进行范围修改；而这道题意思是每一项之前有多少大于等于它的。
把样例换一个角度看，就把他们一个一个输入，例如第一组样例：输入9时，前面没有比它大的，不必交换，
输入1时，前面有个9，需要交换一次，变成1，9；输入0时，需要交换两次，先是0和9 交换，成1,0，9，再
0和1交换，0,1,9；
依次类推，计算最小交换次数，所以等于变相的求每一项前面存在几个大于它的数。
再附上逆序数的概念：
也就是说，对于n个不同的元素，先规定各元素之间有一个标准次序（例如n个 不同的自然数，可规定
从小到大为标准次序），于是在这n个元素的任一排列中，当某两个元素的先后次序与标准次序不同时
，就说有1个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。
而这道题，你会发现，至少交换多少次就是找这个排列有多少逆序数。
就拿样例来说吧：规定是从小到大排列，对于排列 9 1 0 5 4；所以这个排列应该是递增的。
所以，对于9来说，前面没有比它大的，也就是9的逆序数是0，对于1，前面有一个比他大，所以
1的逆序数是1，以此类推，0的逆序数是2,5的是1,4的是2.而对于这个排列来说，逆序数等于各个数
的逆序数的和，也就是6.
C++版本一
树状数组
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
int n;
int t[500004],s[500004];
struct node{
int v,x;
bool operator <(const node &b)const{
return v<b.v;
}
} a[500003];
int lowbit(int n){
return n&(-n);
}
void updata(int x,int y){
while(x<=n){
s[x]+=y;
x+=lowbit(x);
}
}
int query(int x){
int sum=0;
while(x){
sum+=s[x];
x-=lowbit(x);
}
return sum;
}
int main()
{
while(scanf("%d",&n)!=EOF&&n){
memset(s,0,sizeof(s));
for(int i=1; i<=n; i++){
scanf("%d",&a[i].v);
a[i].x=i;//离散化
}
sort(a+1,a+n+1);
for(int i=1;i<=n;i++){
t[a[i].x]=i;
}
long long ans=0;
for(int i=1;i<=n;i++){
updata(t[i],1);
ans+=i-query(t[i]);
}
printf("%lld\n",ans);
}
//cout << "Hello world!" << endl;
return 0;
}
首先介绍线段树的解法：
我们先将原数组每个值附上一个序号index，再将它排序。如题目的例子：
num： 9 1 0 5 4
index： 1 2 3 4 5
排序后：
num： 0 1 4 5 9
index： 3 2 5 4 1
然后由于排序后num为0的点排在原来数组的第3个，所以为了将它排到第一个去，那就至少需要向前移动两次，同时它也等价于最小的数0之前有2个数比它大（所以要移动两次），将0移到它自己的位置后，我们将0删掉（目的是为了不对后面产生影响）。再看第二大的数1，它出现在原数组的第二个，他之前有一个数比它大所以需要移动一次。这样一直循环下去那么着5个数所需要移动的次数就是：
num： 0 1 4 5 9
次数 2 1 2 1 0
将次数全部要加起来就是最后所需要移动的总次数。
方法章爷是已经告诉我了，但是最初我一直是觉得不好实现。到后来才慢慢、慢慢弄好。方法就是在建一棵树时，不是直接将原来的num放进树里面，而是将它的下标放进树里面，最初每个节点上赋值为1.然后当查找第一个num时，由于是找的下标为3的位置，所以我们就直接找区间[1,3)之间有多少个1（就是求前导和），这里面1的个数就是第一个num=0索要移动的次数，然后我们把0去掉，其实也就是吧下标为3的那个1去掉。这样每个值就依次计算出来了。
当然其实只要是想明白了，不用线段树，直接用树状数组写起来会简便很多。（因为每次只需要计算前导和以及去掉某一个点，是对点的操作）。
这里再讲一下归并排序的方法（对于最基础就没有掌握好的我来说听到他们说归并排序可以解题时，我竟然一团雾水，竟然连归并排序都忘记了），看了一下归并排序的实现过程，其实马上就可以找到思路，由于本题实际上就是要求逆序对（即满足i<j，a[i]>a[j]的数对）的个数。而我们再回顾一下归并排序的过程：
假设回溯到某一步，后面的两部分已经排好序（就是说当前需要归并的两个部分都是分别有序的），假设这两个序列为
序列a1：2 3 5 9
序列a2：1 4 6 8
此时我们的目的就是要将a1和a2合并为一个序列。
由于在没排序前a2序列一定全部都是在a1序列之后的，当我们比较a2的1与a1的2时，发现1<2按照归并的思想就会先记录下a2的1，而这里实际上就是对冒泡排序的优化，冒泡是将a2的1依次与a1的9,5,3,2交换就需要4次，而归并却只有一次就完成了，要怎么去记录这个4呢，实际上由于1比2小而2后面还有4个数，也就是说那我的结果就必须要+4，也就是记录a1序列找到第一个比a2某一个大的数，他后面还余下的数的个数就是要交换的次数。
同时我们看a2的4时，a1中第一个比它大的数是5,5之后共有两个数，那结果就+2,。依次下去就可以计算出结果。但是由于我们任然没有改变归并排序的过程。所以复杂度还是O(nlogn)，比上面的线段树要快。
C++版本二
归并排序
#include <stdio.h>
#include <string.h>
#define mem(a) memset(a, 0, sizeof(a))
int N, A[500010], T[500010];
__int64 ans;
void Merg_Sort(int x,int y)
{
if(y-x<=1) return ;
int mid = x + (y-x)/2;
Merg_Sort(x,mid);
Merg_Sort(mid,y);
int p = x, q = mid, i=x;
while(p<mid || q<y)
{
if(q>=y || (p<mid && A[p] <= A[q])) T[i++] = A[p++];
else//else的条件是(p==mid || A[q] < A[p])
{
if(p<mid) ans+=(mid-p);//由于是p<mid,所以此时也就是相当于 A[q] < A[p]
T[i++] = A[q++]; //上面同时A[p]是第一个<A[q]的数，所以+后面还有的数(mid-p)
}
}
for(i=x;i<y;i++)
{
A[i] = T[i];
}
}
int main()
{
while(~scanf("%d", &N) && N)
{
mem(A); mem(T);
for(int i=0;i<N;i++)
{
scanf("%d", &A[i]);
}
ans = 0;
Merg_Sort(0,N);
printf("%I64d\n",ans);//结果会超int32
}
return 0;
} C++版本三
树状数组
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define mem(a) memset(a,0,sizeof(a))
#define MIN(a , b) ((a) < (b) ? (a) : (b))
#define MAXN 500010
#define INF 1000000007
#define lson k<<1, l, mid
#define rson (k<<1)|1, mid+1, r
using namespace std;
int Tree[MAXN<<2], index[MAXN], num[MAXN];
int N;
int cmp(const int i, const int j)
{
return num[i] < num[j];
}
void Edit(int k, int l, int r, int num, int value)
{
Tree[k] += value;
if(r==l) return ;
int mid = (l+r) >> 1;
if(num <= mid) Edit(lson, num, value);
else Edit(rson, num, value);
}
int Search(int k, int l, int r, int L, int R)//L,R是要找的区间
{
if(L<=l && r<=R) return Tree[k];
int mid = (l+r) >> 1;
int ans = 0;
if(L <= mid) ans += Search(lson, L, R);
if(R > mid) ans += Search(rson, L, R);
return ans;
}
int main()
{
while(~scanf("%d", &N) && N)
{
mem(Tree); mem(num); mem(index);
for(int i=1;i<=N;i++)
{
scanf("%d", &num[i]);
Edit(1, 1, N, i, 1);
index[i] = i;
}
sort(index+1, index+N+1,cmp);
long long ans = 0;
for(int i=1;i<=N;i++)
{
ans += (Search(1, 1, N, 1, index[i])-1);
Edit(1, 1, N, index[i], -1);
}
printf("%I64d\n", ans);
}
return 0;
} C++版本四
题目大意：
给出长度为n的序列，每次只能交换相邻的两个元素，问至少要交换几次才使得该序列为递增序列。
解题思路：
一看就是冒泡，交换一次记录一次就可以了
但是n的范围达到50W，冒泡O(n^2)的复杂度铁定超时（即使有7000ms，其实这是一个陷阱）
直接用快排又不符合题目的要求（相邻元素交换），快排是建立在二分的基础上的，操作次数肯定比在所要求的规则下的交换次数要更少
那么该怎么处理？
其实这题题目已经给出提示了：Ultra-QuickSort
特殊的快排，能和快排Quicksort相媲美的就是归并排序Mergesort了，O(nlogn)
但是用归并排序并不是为了求交换次数，而是为了求序列的 逆序数（学过《线代》的同学应该很熟悉了）
一个乱序序列的 逆序数 = 在只允许相邻两个元素交换的条件下,得到有序序列的交换次数
例如例子的
9 1 0 5 4
由于要把它排列为上升序列，上升序列的有序就是 后面的元素比前面的元素大
而对于序列9 1 0 5 4
9后面却有4个比9小的元素，因此9的逆序数为4
1后面只有1个比1小的元素0，因此1的逆序数为1
0后面不存在比他小的元素，因此0的逆序数为0
5后面存在1个比他小的元素4, 因此5的逆序数为1
4是序列的最后元素，逆序数为0
因此序列9 1 0 5 4的逆序数 t=4+1+0+1+0 = 6 ，恰恰就是冒泡的交换次数
PS：注意保存逆序数的变量t，必须要用__int64定义，int和long都是无法保存的。。。。会导致WA。 以前的long long 在现在的VC编译器已经无法编译了。
注意__int64类型的输出必须使用指定的c格式输出，printf(“%I64d”,t);
cout是无法输出__int64类型的
序列数组s[]用int就足够了，每个元素都是小于10E而已
#include<iostream>
using namespace std;
const int inf=1000000000; //10E
__int64 t; //s[]数列逆序数
void compute_t(int* s,int top,int mid,int end)
{
int len_L=mid-top+1;
int len_R=end-mid;
int* left=new int[len_L+2];
int* right=new int[len_R+2];
int i,j;
for(i=1;i<=len_L;i++)
left[i]=s[top+i-1];
left[len_L+1]=inf; //设置无穷上界，避免比较大小时越界
for(j=1;j<=len_R;j++)
right[j]=s[mid+j];
right[len_R+1]=inf; //设置无穷上界，避免比较大小时越界
i=j=1;
for(int k=top;k<=end;)
if(left[i]<=right[j])
s[k++]=left[i++];
else
{
s[k++]=right[j++];
t+=len_L-i+1; //计算逆序数
}
delete left;
delete right;
return;
}
void mergesort(int* s,int top,int end)
{
if(top<end)
{
int mid=(top+end)/2;
mergesort(s,top,mid);
mergesort(s,mid+1,end);
compute_t(s,top,mid,end);
}
return;
}
int main(void)
{
int n; //序列长度
while(cin>>n)
{
if(!n)
break;
/*Input*/
int* s=new int[n+1];
for(int i=1;i<=n;i++)
cin>>s[i];
/*Merge-Sort*/
t=0; //initial
mergesort(s,1,n);
/*Output*/
printf("%I64d\n",t);
/*Relax*/
delete s;
}
return 0;
}
京公网安备 11010502036488号