poj 2299 树状数组入门

点击打开链接

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 63697		Accepted: 23752

Description


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

说白了，求逆序数。
可以用线段树或树状数组或归并排序法写

9 1 0 5 4

1 2 3 4 5

排序后就是

0 1 4 5 9

3 2 5 4 1

然后求0的逆序数，0在之前的数组里下标为3，0目前是最小的数且前面有2个数，那么0的逆序数就是2，算完0的逆序数就删除0；

然后求1的逆序数，1在原数组中下标为2，因为删除了0，1是最小的数，1前面有一个数，1的逆序数为1，再删除1；

然后求4的逆序数，4在原数组下标为5，因为删除了0和1,4前面的数只有2个，因此4的逆序数为2，删除4；

依次类推

思路是这样，那么求值和删除的过程中可用树状数组或线段树维护

树状数组:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct node
{
int num;
int data;
}a[1000000];
int c[600000];
long long ans=0;
bool cmp(node c,node d)
{
return c.data<d.data;
}
void insert(int i,int n,int key)
{
while(i<=n)
{
c[i]+=key;
i+=i&(-i);
}
}
void getsum(int i)
{
while(i>0)
{
ans+=c[i];
i-=i&(-i);
}
}
int main()
{
int n;
while(~scanf("%d",&n)&&n)
{
int i;
memset(c,0,sizeof(c));
for(i=1;i<=n;i++)
{
scanf("%d",&a[i].data);
a[i].num=i;
insert(i,n,1);
}
sort(a+1,a+n+1,cmp);
ans=0;
for(i=1;i<=n;i++)
{
getsum(a[i].num);
ans--;//之前计算的时候包括了a[i].num本身，因此算出来的结果要-1;
insert(a[i].num,n,-1);
}
printf("%lld\n",ans);
}
}

线段树：
#include<cstdio>
#include<algorithm>
using namespace std;
struct node
{
int num;
int data;
}a[600000];
int tree[2000000];
long long ans;
bool cmp(node c,node d)
{
return c.data<d.data;
}
void build(int l,int r,int node)
{
if(l==r)
{
tree[node]=1;
return;
}
int m=(l+r)/2;
build(l,m,node*2);
build(m+1,r,node*2+1);
tree[node]=tree[node*2]+tree[node*2+1];
}
void query(int l,int r,int node,int ql,int qr)
{
if(l>=ql&&r<=qr)
{
ans+=tree[node];
return;
}
int m=(l+r)/2;
if(m<qr)
query(m+1,r,node*2+1,ql,qr);
if(m>=ql)
query(l,m,node*2,ql,qr);
}
void update(int l,int r,int node,int pos)
{
if(l==r)
{
tree[node]=0;
return;
}
int m=(l+r)/2;
if(m>=pos)
update(l,m,node*2,pos);
else
update(m+1,r,node*2+1,pos);
tree[node]=tree[node*2]+tree[node*2+1];
}
int main()
{
int n;
while(~scanf("%d",&n)&&n)
{
int i;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i].data);
a[i].num=i;
}
sort(a+1,a+n+1,cmp);
build(1,n,1);
ans=0;
for(i=1;i<=n;i++)
{
query(1,n,1,1,a[i].num);
ans--;//之前计算的时候包括了a[i].num本身，因此算出来的结果要-1;
update(1,n,1,a[i].num);
}
printf("%lld\n",ans);
}
}

归并排序法：

#include<stdio.h>
int a[1000005],temp[1000005];
long long count;
void Merge_sort(int L,int mid,int R)
{
int i=L,j=mid+1,k=L;
while(i<=mid&&j<=R)
{
if(a[i]<=a[j])
temp[k++]=a[i++];
else
{
temp[k++]=a[j++];
count+=(mid-i+1);
}
}
while(i<=mid)
temp[k++]=a[i++];
while(j<=R)
temp[k++]=a[j++];
for(i=L;i<=R;i++)
a[i]=temp[i];
}
void Merge(int L,int R)
{
if(L<R)
{
int mid=(L+R)/2;
Merge(L,mid);
Merge(mid+1,R);
Merge_sort(L,mid,R);
}
}
int main()
{
int N;
while(~scanf("%d",&N)&&N)
{
int i;
for(i=0;i<N;i++)
scanf("%d",&a[i]);
count=0;
Merge(0,N-1);
printf("%lld\n",count);
}
}