问题描述
n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列,但是每次只能交换位置相邻的两个小朋友。
每个小朋友都有一个不高兴的程度。开始的时候,所有小朋友的不高兴程度都是0。
如果某个小朋友第一次被要求交换,则他的不高兴程度增加1,如果第二次要求他交换,则他的不高兴程度增加2(即不高兴程度为3),依次类推。当要求某个小朋友第k次交换时,他的不高兴程度增加k。
请问,要让所有小朋友按从低到高排队,他们的不高兴程度之和最小是多少。
如果有两个小朋友身高一样,则他们谁站在谁前面是没有关系的。
每个小朋友都有一个不高兴的程度。开始的时候,所有小朋友的不高兴程度都是0。
如果某个小朋友第一次被要求交换,则他的不高兴程度增加1,如果第二次要求他交换,则他的不高兴程度增加2(即不高兴程度为3),依次类推。当要求某个小朋友第k次交换时,他的不高兴程度增加k。
请问,要让所有小朋友按从低到高排队,他们的不高兴程度之和最小是多少。
如果有两个小朋友身高一样,则他们谁站在谁前面是没有关系的。
输入格式
输入的第一行包含一个整数n,表示小朋友的个数。
第二行包含 n 个整数 H1 H2 … Hn,分别表示每个小朋友的身高。
第二行包含 n 个整数 H1 H2 … Hn,分别表示每个小朋友的身高。
输出格式
输出一行,包含一个整数,表示小朋友的不高兴程度和的最小值。
样例输入
3
3 2 1
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)
3.不用排序的统计逆序数 (排序的目的就是离散化,此题数据的范围不是特别大,可以直接做)
对于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