hdu 1394 Minimum Inversion Number（暴力/线段树/树状数组）

题目：http://acm.hdu.edu.cn/showproblem.php?pid=1394

题意：一个数列可以把任意队首元素挪到对尾，求这些可能中最小的逆序对数，数列由0，到n-1组成。

暴力：可以通过这个数据看出这个结论。

如果求出第一种情况的逆序列，其他的可以通过递推来搞出来，一开始是t[1],t[2],t[3]....t[N]

它的逆序列个数是N个，如果把t[1]放到t[N]后面，逆序列个数会减少t[1]个，相应会增加N-(t[1]+1)个 

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n,a[5005],cnt;
    while(scanf("%d",&n)!=EOF){
        int ans=999999999;
        cnt=0;
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++)
                if(a[i]>a[j])
                    cnt++;
        if(ans>cnt)
            ans=cnt;
        for(int i=0;i<n;i++){
            cnt=cnt-a[i]+n-1-a[i];
            if(ans>cnt)
                ans=cnt;
        }
        printf("%d\n",ans);
    }
    return 0;
}

神奇的线段树：

仍然是刚才结论，与刚才类似，只是线段树将n^2优化了下。

1.按顺序建一棵空树，以后叶子结点的sum都放一

2.每次for查有几个比他大的，即a【i】到n-1有几个数，

3.update要在后面，因为查的时候不能包扩a[i]

/*都从 1 开始建树，保持习惯*/
#include<cstdio>
#define N 50050
int num[N];
struct Tree{
    int l;
    int r;
    int sum;
}tree[4*N];


void build(int t,int l,int r){
    tree[t].l=l;
    tree[t].r=r;
    tree[t].sum=0;
    if(tree[t].l==tree[t].r){
        tree[t].sum=0;
        return;
    }
    int mid=(l+r)/2;
    build(2*t,l,mid);
    build(2*t+1,mid+1,r);
    //tree[t].sum=tree[2*t].sum+tree[2*t+1].sum;
}
void update(int t,int pos,int val){
    if(tree[t].l==tree[t].r){
        tree[t].sum++;
        return;
    }
    int mid=(tree[t].l+tree[t].r)/2;
    if(pos<=mid)
        update(2*t,pos,val);
    else
        update(2*t+1,pos,val);
    tree[t].sum=tree[2*t].sum+tree[2*t+1].sum;
}
int query(int t,int l,int r){
    if(l<=tree[t].l&&r>=tree[t].r)
        return tree[t].sum;
    int mid=(tree[t].l+tree[t].r)/2,ans=0;
    if(l<=mid) ans+=query(2*t,l,r);
    if(r>mid)  ans+=query(2*t+1,l,r);
    return ans;
}


int main(){
    int n,a[5005],sum;
    while(scanf("%d",&n)!=EOF){
        sum=0;
        int ans=999999999;
        build(1,1,n);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=n;i++){
            sum+=query(1,a[i]+1,n);
            update(1,a[i],1);
        }
        if(ans>sum)
            ans=sum;
        //printf("%d\n",sum);
        for(int i=1;i<=n;i++){
            sum=sum-a[i]+n-1-a[i];
            if(ans>sum)
                ans=sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}

求逆序对最快的是树状数组

#include<bits/stdc++.h>
using namespace std;

int n,tree[100005],a[5005];

int lowbit(int i){
    return i&(-i);
}
void update(int i,int x){
    while(i<=n){
        tree[i]+=x;
        i+=lowbit(i);
    }
}
int query(int i){
    int sum=0;
    while(i>0){
        sum+=tree[i];
        i-=lowbit(i);
    }
    return sum;
}
int main(){
    while(scanf("%d",&n)!=EOF){
        memset(tree,0,sizeof(tree));
        int sum=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            update(a[i]+1,1);
            sum+=i-query(a[i]+1);
        }
        int ans=sum;
        for(int i=1;i<=n;i++){
            sum=sum-a[i]+n-1-a[i];
            if(ans>sum)
                ans=sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}