转载原地址:https://blog.csdn.net/Du_Mingm/article/details/81203260
首先,逆序数的定义
什么叫逆序数
对于某一个数来说,它的逆序数等于在它之前有多少个比它大的数
对于某一个序列来说,逆序数等于所有数的逆序数之和
例如
序列 5 1 5 2
逆序数 0 1 0 2
序列的逆序数 1+2=3
来看逆序数的求法
方法一
首先将定义一个结构体,存数列的值和下标,然后按数值从大到小(数值相同按下标从大到小)sort一下
然后建立树状数组,从最大的元素开始,将其标记,即 add(p【i】.id,1)
利用其query(i)查询当前1----i的和
对于第i大的数,由于之前所有比它大的数已经标记,所以query(i)就是当前数的逆序数
例如 5 6 3 8 2 其排序之后即是 2 3 5 6 8 将求对应的值的逆序数的问题转化成了求下标对应的逆序数按求逆
1 2 3 4 5 5 3 1 2 4
序数的方法,先求下标的逆序数 即: 0 + 1 + 2 + 2 + 1 = 6 ,答案即是序列的逆序数,
换一种思路来看, 为了避免加入顺序而导致逆序数的不正确,所以从后面开始逆序,因为已经转化成下标的逆序
所以只需看下标即可, 5 3 1 2 4 对于4的逆序只有5,在c[5]+1,
对于2的逆序有5,3,在c[5]+1,c[3]+1
其余类似。。。。。
然后对于3来说的树状数组求1~3的和,即是求以3为逆序数(此例是1,2)的数的个数,
同理对于 i 来求1~i 之间的和,就是来求以 i 为逆序数的数的个数,最后求个总和,也就是所要求的该数列的逆序数。
代码:
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int c[100010];
typedef struct nodee{
int x,num;
}node;
node maze[10010];
bool cmp(node u,node v)
{
if(u.x==v.x)
return u.num>v.num;
return u.x<v.x;
}
int lowbit(int x)
{
return x&(-x);
}
void add(int x)
{
while(x<100005){
c[x]+=1;
x+=lowbit(x);
}
}
int summ(int x)
{
int sum=0;
while(x>0){
sum+=c[x];
x-=lowbit(x);
}
return sum;
}
int main()
{
int n,i;
while(scanf("%d",&n)!=EOF){
memset(c,0,sizeof(c));
for(i=1;i<=n;i++){
scanf("%d",&maze[i].x);
maze[i].num=i;
}
sort(maze+1,maze+n+1,cmp);
int sum=0;
for(i=n;i>=1;i--){
int y=maze[i].num;
sum+=summ(y);
add(y);
}
printf("%d\n",sum);
}
return 0;
}
方法二
也是树状数组,不过要离散化处理
所谓的离散化就是将数组排个序,例如从小到大排序,
那么将第一小记做1,第二小记做2,那么就算是离散化了
(离散,字面意思,分离,散开,分成一个个的小块,当然每个块不能相同)
这个处理的话就是这样
序列 5 1 5 2
离散化数组 3 1 3 2
这样从最小的数开始建立树状数组(标记)
那么i-query(b【i】)就是当前数的逆序数(i为当前第i个的数,b【i】是当前数是第几小,
query询问的是1------i有多少个标记的数(小于等于当前数的数),i-query(b【i】)自然是大于当前数 的数 的个数)
例如实例:maze[i].x: 2 5 7 3 4 排序后为 maze[i].x 2 3 4 5 7
maze[i].num 1 2 3 4 5 maze[i].num 1 4 5 2 3
离散化后为: maze[i].x 2 3 4 5 7 按照num的顺序走就是:
maze[i].num 1 4 5 2 3 maze[i].num 1 2 3 4 5
b[maze[i].num] 1 2 3 4 5 b[maze[i].num] 1 4 5 2 3
对于这个例子,maze[i].num 从1~n开始遍历,先add(1),改变后缀和,将比1大的c[i]都加1,
然后add(4),将比4 大的位置都加1
。。。。。以此类推
然后每一次query(b[i]),就代表在i之前有多少比 b[i] 小的数的个数,因为 i 代表b[i] 的位置,即前面有几个数
所以 i-query(b[i]) ,就代表 b[i] 之前有几个比它大的数的个数。
补充一个
离散化三部曲:
1. 数组 ha[] 存储所有存在过的数据,sort排序
2. 对ha数组进行去重,重复的数据只保留一个。unique去重(unique函数前提有序)
3. 查询某个数字离散化之后对应的数字,lower_bound查排名
代码
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
int n,c[100010];
int lowbit(int x)
{
return x&(-x);
}
void add(int k,int num)
{
while(k<=n)
{
c[k]+=num;
k+=lowbit(k);
}
}
int query(int k)
{
int sum=0;
while(k)
{
sum+=c[k];
k-=lowbit(k);
}
return sum;
}
typedef struct nodee
{
int x,i;
}node;
node maze[100010];
bool cmp(node u,node v)
{
if(u.x==v.x)
return u.i>v.i;
return u.x<v.x;
}
int b[100010];
int main(void)
{
int i,j,x,y;
while(~scanf("%d",&n))
{
ll sum = 0;
memset(c,0,sizeof(c));
for(i=1;i<=n;i++)
{
scanf("%d",&maze[i].x);
maze[i].i = i;
}
sort(maze+1,maze+1+n,cmp);
int cnt = 1;
for(i=1;i<=n;i++){
if(i!=1&&maze[i].x!=maze[i-1].x)
cnt++;
b[maze[i].i] = cnt;
}
for(i=1;i<=n;i++)
{
add(b[i],1);
sum += (i-query(b[i]));
}
printf("%lld\n",sum);
}
return 0;
}
方法三
归并求解(我 还 不 会)
相当漂亮的写法,让我写肯定写不了这么好,但是有个问题是b数组的申请,这里频繁申请爆掉了
我给改成了全局变量
#include <bits/stdc++.h>
using namespace std;
long long int cnt;
int a[104000];
int *b;
void Merge(int a[], int low, int mid, int high);
void Merge_sort(int a[], int low, int high);///归并排序
int main(){
int n, i;
scanf("%d", &n);
for(i = 0; i < n; i++)
scanf("%d", &a[i]);
b = new int[n];
cnt = 0;
Merge_sort(a, 0, n-1);
delete[] b;
printf("%lld\n", cnt);
return 0;
}
void Merge_sort(int a[], int low, int high){
int mid;
if(low < high){
mid = (low + high)/2;
Merge_sort(a, low, mid);
Merge_sort(a, mid+1, high);
Merge(a, low, mid, high);
}
}
void Merge(int a[], int low, int mid, int high){///可类比两组有序链表的归并,思想基本一样
int i = low;
int j = mid + 1;
int k = 0;
//int *b = new int[high-low+1];///动态申请内存
while(i <= mid && j <= high){
if(a[i] <= a[j])
b[k++] = a[i++];
else {
b[k++] = a[j++];
cnt += (mid - i + 1);///归并两组有序数据,当a[i] > a[j], 则在区间[i, mid]的数据全部大于a[j],此时对于a[j]的逆序数为(mid - i + 1)
}
}
while(i <= mid){
b[k++] = a[i++];
}
while(j <= high){
b[k++] = a[j++];
}
for(k = 0, i = low; i <= high; i++, k++){
a[i] = b[k];
}
}
方法四
直接数 的就不写了