历届试题 小朋友排队

问题描述

　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。

　　每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。

　　如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。

　　请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。

　　如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。

输入格式

　　输入的第一行包含一个整数n，表示小朋友的个数。
　　第二行包含 n 个整数 H1 H2 … Hn，分别表示每个小朋友的身高。

输出格式

　　输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。

样例输入

3
3 2 1

样例输出

9

样例说明

　　首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。

数据规模和约定

　　对于10%的数据， 1<=n<=10；
　　对于30%的数据， 1<=n<=1000；
　　对于50%的数据， 1<=n<=10000；
　　对于100%的数据，1<=n<=100000，0<=Hi<=1000000。

看到这样的数据量，就知道直接模拟，一定是没有戏的，把自己的代码全都贴出来吧
1.暴力（60）

#include <cstdio>
#include <cstring>
#include <cmath>
typedef long long ll;

const int maxn=100000;
struct node{
	int val;
	ll time;
}num[maxn],tmp;

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    	scanf("%d",&num[i].val);
	
	for(int i=0;i<n;i++){
		int flag=0;
		for(int j=1;j<n;j++){
			if(num[j].val<num[j-1].val){
				flag=1;
				num[j].time++;
				num[j-1].time++;
				tmp=num[j];
				num[j]=num[j-1];
				num[j-1]=tmp;
			}	
		}
		if(!flag)
			break;
	}
	ll ans=0;
	for(int i=0;i<n;i++){
		ll tmp=num[i].time;
		//printf("*val:%d %lld ",num[i].val,num[i].time);
		ans+=(tmp*(1+tmp)/2);
	}
	printf("%lld\n",ans);
    return 0;
}

2.看到了逆序数，自己模拟着用树状数组实现了一下（80）

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#define lowbit(x)  (x&(-x))

using namespace std;
typedef long long ll;
const int maxn=100000; 

struct node{
	ll val;
	int inorder;
	bool operator <(const node& other)const{
		if(val==other.val)
			return inorder<other.inorder;
		return val<other.val;
	}
}val[maxn];

ll sum[maxn],sum2[maxn]; 

ll tree[maxn];
int aa[maxn];
int n;

void update(int now,int num){
	while(now<=n){
		tree[now]+=num;
		now+=lowbit(now);
	}
}

ll getsum(int now){//统计的是前面比now小的值 
	ll ans=0;
	while(now>0){
		ans+=tree[now];
		now-=lowbit(now);
	}
	return ans;
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
    	scanf("%lld",&val[i].val); 
    	val[i].inorder=i;
	}
    sort(val+1,val+n+1);
	for(int i=1;i<=n;i++)
		aa[val[i].inorder]=i;//离散化数值，要不然，val的范围太大了， 
	for(int i=1;i<=n;i++){//统计前面比他大的值 ，所以得把他自己去掉， 
		update(aa[i],1);
		sum[i]=i-getsum(aa[i]);
	}
	ll ans=0;
	memset(tree,0,sizeof(tree));
	for(int i=n;i>=1;i--){//统计后面比他小的值 
		sum[i]+=getsum(aa[i]);
		update(aa[i],1);
		ll tmp=sum[i];
		ans+=(tmp+1)*tmp/2; 
	}
	printf("%lld\n",ans);
    return 0;
}

还是没有得满分，我觉得主要就是这个排序是没有必要的，本来就是一个统计逆序数，只需要根据大小就好了，没有必要sort一下
3.不用排序的统计逆序数 （排序的目的就是离散化，此题数据的范围不是特别大，可以直接做）

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#define lowbit(x)  (x&(-x))

using namespace std;
typedef long long ll;
const int maxn=1000010; 

ll val[maxn]; 
ll sum[maxn*10]; 
ll tree[maxn*10];

int n;

void update(int now,int num){
	while(now<=maxn){
		tree[now]+=num;
		now+=lowbit(now);
	}
}

ll getsum(int now){//统计的是前面比now小的值 
	ll ans=0;
	while(now>0){
		ans+=tree[now];
		now-=lowbit(now);
	}
	return ans;
}


int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
    	scanf("%lld",&val[i]); 
    	val[i]+=2;
	}
	for(int i=1;i<=n;i++){//统计前面小于等于它的值 ，相等的也不能要,所以我们先update,然后再getsum,这样的话，我们的getsum就是大于了 
		update(val[i],1);
		sum[i]=i-getsum(val[i]);//记录的交换次数 
	}
	ll ans=0;
	memset(tree,0,sizeof(tree));
	for(int i=n;i>=1;i--){//统计后面比他小的值，所以想等的不能要  ，所以见一 
		update(val[i],1);
		sum[i]+=getsum(val[i]-1);
	}
	for(int i=1;i<=maxn+10;i++){
		ll tmp=sum[i];
		ans+=tmp*(tmp+1)/2;
	} 
	printf("%lld\n",ans);
    return 0;
}

4. 归并排序实现

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#define lowbit(x)  (x&(-x))

using namespace std;
typedef long long ll;
const int maxn=100010; 

struct node{
	int val;
	ll num;
}a[maxn],tmp[maxn]; 

void Merge_sort(int st,int ed){
	if(st==ed)
		return ;
	int mid=(st+ed)/2;
	int i=st,j=mid+1,k=st;
	Merge_sort(st,mid);
	Merge_sort(mid+1,ed);
	while(i<=mid&&j<=ed){
		if(a[i].val<=a[j].val){
			a[i].num+=k-st-(i-st+1)+1;//
			tmp[k++]=a[i++];
		} 
		else{
			a[j].num+=mid-i+1;
			tmp[k++]=a[j++];
		}
	} 
	while(i<=mid){
		a[i].num+=k-st+1-(i-st+1);//
		tmp[k++]=a[i++];
	}
	while(j<=ed)
		tmp[k++]=a[j++];
		
	for(int i=st;i<=ed;i++)
		a[i]=tmp[i]; 
}

int main()
{
	int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
    	scanf("%lld",&a[i].val); 
	}
	Merge_sort(1,n) ;
	ll ans=0;
	for(int i=1;i<=n;i++){
		ll tmp=a[i].num;
		ans+=tmp*(tmp+1)/2;
	}
	/*
	for(int i=1;i<=n;i++)
		printf("%d %d\n",a[i].val,a[i].num);
	*/
	printf("%lld\n",ans);
    return 0;
}

现在内心终于对这个逆序数是个什么东西有点感觉了，就是一个必须要交换的次数 ，321，逆序数就是3，所以你要交换三次，231 213 123