归并求逆序数 树状数组求逆序数 线段树求逆序数

归并求逆序数看这个

http://ip96cns.blog.163.com/blog/static/1700951922010102683834855/

 

#include<stdio.h>
#include<string.h>
#define maxn 10010
int a[maxn],b[maxn],res;
void merge(int l,int mid,int r)
{
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r)
    {
        if(a[i]>a[j])
        {
            b[k++]=a[j++];
            res+=(mid-i+1);
        }
        else
        {
            b[k++]=a[i++];
        }
    }
    while(i<=mid)
    {
        b[k++]=a[i++];
    }
    while(j<=r)
    {
        b[k++]=a[j++];
    }
    for(i=l;i<=r;i++)
    a[i]=b[i];
}

void mergesort(int l,int r)
{
    if(l<r)
    {
        int mid=(l+r)/2;
        mergesort(l,mid);
        mergesort(mid+1,r);
        merge(l,mid,r);
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        int i;
        for(i=0;i<n;i++)
        scanf("%d",&a[i]);
        res=0;
        mergesort(0,n-1);
        printf("%d\n",res);
    }
    return 0;
}

树状数组求逆序数看这个

http://blog.csdn.net/q573290534/article/details/6664902

 

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
using namespace std;

const int maxn=10005;
int n;
int aa[maxn]; //离散化后的数组
int c[maxn];    //树状数组

struct Node{
   int v;
   int order;
}in[maxn];

int lowbit(int x)
{
    return x&(-x);
}

void update(int t,int value)
{
    int i;
    for(i=t;i<=n;i+=lowbit(i))
    {
        c[i]+=value;
    }
}

int getsum(int x)
{
    int i;
    int temp=0;
    for(i=x;i>=1;i-=lowbit(i))
    {
        temp+=c[i];
    }
    return temp;
}

bool cmp(Node a ,Node b)
{
    return a.v<b.v;
}

int main()
{
    int i,j;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        //离散化
        for(i=1;i<=n;i++)
        {
            scanf("%d",&in[i].v);
            in[i].order=i;
        }
        sort(in+1,in+n+1,cmp);
        for(i=1;i<=n;i++) aa[in[i].order]=i;
        //树状数组求逆序
        memset(c,0,sizeof(c));
        long long ans=0;
        for(i=1;i<=n;i++)
        {
            update(aa[i],1);
            ans+=i-getsum(aa[i]);
        }
        cout<<ans<<endl;
    }
    return 0;
}

HDU 1394 尝试了下用线段树求逆序树

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 20010
#define inf 9999999
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
typedef long long ll;
struct node
{
    int l,r,num;
}tree[maxn];
int a[maxn];
int n;
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].num=0;
    if(l==r) return;
    int mid=(l+r)/2;
    build(lson);
    build(rson);
}
void update(int rt,int x)
{
    tree[rt].num++;
    if(tree[rt].l==tree[rt].r) return;
    int mid=(tree[rt].l+tree[rt].r)/2;
    if(x<=mid)
    update(2*rt,x);
    else
    update(2*rt+1,x);
}
int query(int rt,int l,int r)
{
    if(l>r)
    return 0;
    if(tree[rt].l==l&&tree[rt].r==r)
    return tree[rt].num;
    int mid=(tree[rt].l+tree[rt].r)/2;
    if(r<=mid)
    return query(2*rt,l,r);
    else if(l>mid)
    return query(2*rt+1,l,r);
    else
    return query(2*rt,l,mid)+query(2*rt+1,mid+1,r);
}
int main()
{
    freopen("in.txt","r",stdin);
    while(scanf("%d",&n)==1)
    {
       int i;
       for(i=0;i<n;i++)
       scanf("%d",&a[i]);
       build(1,0,n-1);
       int sum=0;
       for(i=0;i<n;i++)
       {
           sum+=query(1,a[i]+1,n-1);
           update(1,a[i]);
       }
       int ans=sum;
       for(i=0;i<n-1;i++)
       {
           sum+=(n-1-a[i])-a[i];
           if(sum<ans)
           ans=sum;
       }
       printf("%d\n",ans);
    }
    return 0;
}