洛谷 P1908 逆序对 归并排序/离散化+树状数组/离散化+线段树

洛谷 P1908 逆序对   归并排序/离散化+树状数组/离散化+线段树

方法一：自小到大的归并排序   1之前，比1大的有5个

//1.52s / 4.55MB / 638B C++
//P1908 逆序对
//在线测评地址https://www.luogu.org/problem/P1908
//(500000+1)*500000/2=1.25*10^11 int 溢出，需采用long long
//第1步，要会编写归并排序。
//采用自小到大的归并排序
/*
6
5 4 2 6 3 1
5之前，比5大的有0个
4之前，比4大的有1个
2之前，比2大的有2个
6之前，比6大的有0个
3之前，比3大的有4个
1之前，比1大的有5个
*/
//样例通过，提交AC.
#include <stdio.h>
#define LL long long
#define maxn 500100
int a[maxn],n,b[maxn];
LL cnt=0;
void memory_sort(int s1,int e1,int s2,int e2){
    int i=s1,j=s2,k=s1;
    while(i<=e1&&j<=e2){
        if(a[i]<=a[j])b[k++]=a[i++];
        else cnt+=s2-i,b[k++]=a[j++];//a[i]---a[e1]数据都比a[j]大,也可写成cnt+=e1-i+1;//此处错写成else cnt+=j-i,b[k++]=a[j++];通过跟踪代码才进行了修改。2019-10-29
    }
    while(i<=e1)b[k++]=a[i++];
    while(j<=e2)b[k++]=a[j++];
    for(i=s1;i<=e2;i++)a[i]=b[i];
}
void merge_sort(int left,int right){
    int mid=(left+right)/2;
    if(left>=right)return;
    merge_sort(left,mid);
    merge_sort(mid+1,right);
    memory_sort(left,mid,mid+1,right);
}
int main(){
    int i;
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d",&a[i]);
    merge_sort(1,n);
    printf("%lld\n",cnt);
    return 0;
}

方法二：自大到小的归并排序   1之后，比1小的有5个

1.51s / 4.48MB / 664B C++
//P1908 逆序对
//在线测评地址https://www.luogu.org/problem/P1908
//(500000+1)*500000/2=1.25*10^11 int 溢出，需采用long long
//第1步，要会编写归并排序。
//采用自大到小的归并排序
/*
6
5 4 2 6 3 1
5之后，比5小的有0个
4之后，比4小的有1个
2之后，比2小的有2个
6之后，比6小的有0个
3之后，比3小的有4个
1之后，比1小的有5个
*/
//样例通过，提交AC.
#include <stdio.h>
#define LL long long
#define maxn 500100
int a[maxn],n,b[maxn];
LL cnt=0;
void memory_sort(int s1,int e1,int s2,int e2){
    int i=s1,j=s2,k=s1;
    while(i<=e1&&j<=e2){
        if(a[i]>a[j])cnt+=e2-j+1,b[k++]=a[i++];//a[j]---a[e2]之间数据都小于a[i]
        else b[k++]=a[j++];
    }
    while(i<=e1)b[k++]=a[i++];
    while(j<=e2)b[k++]=a[j++];
    for(i=s1;i<=e2;i++)a[i]=b[i];
}
void merge_sort(int left,int right){
    int mid=(left+right)/2;
    if(left>=right)return;
    merge_sort(left,mid);
    merge_sort(mid+1,right);
    memory_sort(left,mid,mid+1,right);
}
int main(){
    int i;
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d",&a[i]);
    merge_sort(1,n);
    printf("%lld\n",cnt);
    return 0;
}

方法三：离散化+树状数组

2.55s / 8.37MB / 716B C++

样例模拟过程如下：

6
5 4 2 6 3 1

a数组
序号1 2 3 4 5 6
数值5 4 2 6 3 1
序号1 2 3 4 5 6

排序后，a数组
序号    1 2 3 4 5 6
数值    1 2 3 4 5 6
序号    6 3 5 2 1 4

离散化后，b数组
序号1 2 3 4 5 6
数值5 4 2 6 3 1

树状数组处理过程如下
加入b[1]=5
()()()()(1)()   此时共有数1个，在b[1]=5之前，包括该数，共有1个。故 逆序对 有 1-1=0个

继续加入b[2]=4
()()()(1)(1)()  此时共有数2个，在b[2]=4之前，包括该数，共有1个。故 逆序对 有 2-1=1个

继续加入b[3]=2
()(1)()(1)(1)()   此时共有数3个，在b[3]=2之前，包括该数，共有1个。故 逆序对 有 3-1=2个

继续加入b[4]=6
()(1)()(1)(1)(1)   此时共有数4个，在b[4]=6之前，包括该数，共有4个。故 逆序对 有 4-4=0个

继续加入b[5]=3
()(1)(1)(1)(1)(1)   此时共有数5个，在b[5]=3之前，包括该数，共有2个。故 逆序对 有 5-2=3个

继续加入b[6]=1
(1)(1)(1)(1)(1)(1)   此时共有数6个，在b[6]=1之前，包括该数，共有1个。故 逆序对 有 6-1=5个

//样例通过，提交AC.2019-10-29
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
#define maxn 500100
using namespace std;
struct node{
    int seq,v;
}a[maxn];
int b[maxn],c[maxn],n;
LL cnt=0;
int cmp(node a,node b){
    return a.v==b.v?a.seq<b.seq:a.v<b.v;
}
int lowbit(int x){
    return x&-x;
}
void add(int x,int delta){
    while(x<=n){
        c[x]+=delta;
        x+=lowbit(x);
    }
}
int sum(int x){
    int ans=0;
    while(x>0){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}
int main(){
    int i;
    memset(c,0,sizeof(c));
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d",&a[i].v),a[i].seq=i;
    sort(a+1,a+1+n,cmp);
    for(i=1;i<=n;i++)b[a[i].seq]=i;//离散化
    for(i=1;i<=n;i++){
        add(b[i],1);
        cnt+=i-sum(b[i]);
    }
    printf("%lld\n",cnt);
    return 0;
}

方法四：离散化+线段树

6.14s / 18.38MB / 1.23KB C++
//离散化+线段树
//此文https://www.luogu.org/problemnew/solution/P1908?page=2   作者: zheng_lw  更新时间: 2018-08-18 15:19思路不错，摘抄如下
/*
介绍一种神奇的算法：
权值线段树

顾名思义，该线段树中存储的并不是普通线段树记录的线段端点，而是 类似一个桶一样的东西

最简单的例子：求逆序对 该题可以用树状数组做，可以用归并排序思想做，可以用splay做...... 不过，既然可以用树状数组用，也可以用线段树做
【思路】

    先建一棵很大的线段树，然后用权值为下标建树，每一次读到一个数，就找比这个数大的个数，找到了之后加到ans里，接着更新线段树（这个数出现的次数+1） PS：这题要加离散化，否则……你懂的
*/
//样例通过，提交AC.2019-10-30  写线段树代码时，建议先画出线段树，对着图进行操作，代码就好写了。
#include <cstdio>
#include <algorithm>
#define LL long long
#define lson k<<1
#define rson k<<1|1
#define M 500100
using namespace std;
int n,b[M];//b[]离散化后的数据
LL ans=0;
struct node{
    int seq,v;
}a[M];
struct tree{
    int left,right,v;
}t[M<<2];//线段树节点
int cmp(node a,node b){
    return a.v==b.v?a.seq<b.seq:a.v<b.v;
}
void build(int k,int left,int right){//建一棵空树
    int mid=(left+right)/2;
    t[k].left=left,t[k].right=right,t[k].v=0;
    if(left==right)return;
    build(lson,left,mid);
    build(rson,mid+1,right);
}
int query(int k,int left,int right){//统计区间，故传入参数left-right
    int mid=(t[k].left+t[k].right)/2,ret=0;
    if(left<=t[k].left&&t[k].right<=right)return t[k].v;
    if(left<=mid)ret+=query(lson,left,right);
    if(mid+1<=right)ret+=query(rson,left,right);
    return ret;
}
void update(int k,int x){//更新包含x的节点，故只需传入x
    int mid=(t[k].left+t[k].right)/2;
    if(t[k].left==t[k].right){
        t[k].v++;
        return;
    }
    if(x<=mid)update(lson,x);
    if(mid+1<=x)update(rson,x);
    t[k].v=t[lson].v+t[rson].v;
}
int main(){
    int i,x;
    scanf("%d",&n);
    for(i=1;i<=n;i++)scanf("%d",&a[i].v),a[i].seq=i;
    sort(a+1,a+1+n,cmp);//自小到大
    for(i=1;i<=n;i++)b[a[i].seq]=i;
    build(1,1,M);//此处错写成build(1,1,n);，造成   段错误
    for(i=1;i<=n;i++){
        x=b[i];
        ans+=query(1,x+1,M);//计算比x大的数据个数
        update(1,x);//在线段树中，更新包含x的节点。
    }
    printf("%lld\n",ans);
    return 0;
}