poj 4020——John’s Inversions

题意：一张牌上面有一个蓝色数字和一个红色数字，问怎么把这些牌排序可以使得所有牌里面的红色数字与蓝色数字的逆序数和最小。
思路：按照一个颜色的数字排序，求另一个数字的逆序数就好了
我用的线段树来求逆序数。看到UESTC的大神用直接归并排序求逆序数给跪了。
逆序数超过了32位整数的范围错了一次。只用将一种颜色的排排序，而不用两边各排序，判断一次导致超时了一次
代码如下：

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<map>
#include<cmath>
#include<assert.h>
#include<iomanip>
#include<assert.h>
using namespace std;

typedef long long ll;

struct Card
{
    int b,r;
}card[100005];
int bsize;
int rsize;
int bc[100005];
int rc[100005];
int n;
bool cmp1(const Card &a,const Card &b)
{
    if(a.b!=b.b)return a.b<b.b;
    return a.r<b.r;
}

bool cmp2(const Card &a,const Card &b)
{
    if(a.r!=b.r)return a.r<b.r;
    return a.b<b.b;
}

ll sumv[400005];

void add(int n,int l,int r,int o)
{
    int mid = (l+r)>>1;
    if(l == r){sumv[o]++;return;}
    else if(n <= mid){
        add(n,l,mid,o*2);
    } else {
        add(n,mid+1,r,o*2+1);
    }
    sumv[o]=sumv[o*2]+sumv[o*2+1];
}

int yl,yr;
int query(int l,int r,int o)
{
    int ret = 0;
    if(yl<=l&&yr>=r)return sumv[o];
    int m = l+((r-l)>>1);
    if(yl<=m)ret+=query(l,m,o*2);
    if(yr>m)ret+=query(m+1,r,o*2+1);
    return ret;
}

int bisearch(int n,int *b,int len)
{
    int l=0;int r=len-1;
    while(l<=r){
        int mid = ((l+r)>>1);
        if(n == b[mid])return mid;
        else if(n < b[mid])r = mid-1;
        else if(n>b[mid])l = mid+1;
    }
    return l;
}

ll inverse(int c)
{
    ll ret = 0;
    memset(sumv,0,sizeof(sumv));
    int sz = c==1?rsize:bsize;
    for(int i=0;i<n;++i){
        int a = c==1?card[i].r:card[i].b;
        int p = bisearch(a,c==1?rc:bc,sz)+1;
        yl = p+1;yr = sz;
        if(yr>=yl)
            ret += query(1,sz,1);
        add(p,1,sz,1);
    }

    return ret;
}

int main()
{
//    freopen("data.txt","r",stdin);

    scanf("%d",&n);
    for(int i=0;i<n;++i){
        scanf("%d%d",&card[i].b,&card[i].r);
        bc[i] = card[i].b;
        rc[i] = card[i].r;
    }
    sort(bc,bc+n);
    sort(rc,rc+n);
    bsize = unique(bc,bc+n)-bc;
    rsize = unique(rc,rc+n)-rc;

    sort(card,card+n,cmp1);
    ll ans=10000000;
    ans = inverse(1);
    printf("%lld\n",ans);
    return 0;
    sort(card,card+n,cmp2);
    ans=min(ans,inverse(2));

}