TYVJ 1744 逆序对数（加强版）

思路：

与a有关的逆序对数=（在a之前出现的比a大的数+在a之后出现的比a小的数）/2

当我们删除a时，减少的是 与a有关的逆序对数，当我们把a的位置填充b时增加的是 与b有关的逆序对数，可以用树状数组求

这样我们相处了nmlogK的算法，显然是不能承受的（K=500000）

但是我们发现当a相同时我们可以将所有的b在logn的时间内算出来，这样复杂度就成了（m+n）logK了

完全可以承受~

PS：不知道为什么我和别人用一样的思路我的代码怎么比他们快3倍啊。。求解释。。（卖萌。。。。）

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

#define N 500010

using namespace std;

struct P
{
    int a,b,id;
}p[N];

int c[N],n,m,a[N],fw[N],inc[N];
__int64 ans[N],anssum;

inline bool cmp(const P &x,const P &y)
{
    return x.a<y.a;
}

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

inline int getsum(int x)
{
    int rt=0;
    while(x)
    {
        rt+=c[x];
        x-=lowbit(x);
    }
    return rt;
}

inline void updata(int x,int dt)
{
    while(x<N)
    {
        c[x]+=dt;
        x+=lowbit(x);
    }
}

void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    
    for(int i=1;i<=n;i++)
    {
        fw[i]=i-1-getsum(a[i]);
        updata(a[i],1);
    }
    memset(c,0,sizeof c);
    
    for(int i=n;i>=1;i--)
    {
        fw[i]+=getsum(a[i]-1);
        updata(a[i],1);
        anssum+=fw[i];
    }
    memset(c,0,sizeof c);
    
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&p[i].a,&p[i].b);
        p[i].id=i;
    }
    
    sort(p+1,p+1+m,cmp);
}

void go()
{
    int sp=1;
    for(int i=1;i<=n;i++)
    {
        while(p[sp].a==i)
        {
            inc[p[sp].id]=i-1-getsum(p[sp].b);
            sp++;
        }
        updata(a[i],1);
    }
    memset(c,0,sizeof c);
    
    sp=m;
    for(int i=n;i>=1;i--)
    {
        while(p[sp].a==i)
        {
            inc[p[sp].id]+=getsum(p[sp].b-1);
            sp--;
        }
        updata(a[i],1);
    }
    anssum/=2;
    for(int i=1;i<=m;i++)
        ans[p[i].id]=anssum-fw[p[i].a]+inc[p[i].id];
    printf("%I64d\n",anssum);
    for(int i=1;i<=m;i++)
        printf("%I64d\n",ans[i]);
}

int main()
{
    read();
    go();
    //system("pause");
    return 0;
}