刷题BZOJ 3295 [Cqoi2011]动态逆序对

Posted oyiya

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了刷题BZOJ 3295 [Cqoi2011]动态逆序对相关的知识,希望对你有一定的参考价值。

Description

对于序列A,它的逆序对数定义为满足iAj的数对(i,j)的个数。给1到n的一个排列,按照某种顺序依次删除m个元素,你的任务是在每次删除一个元素之前统计整个序列的逆序对数

Input

输入第一行包含两个整数n和m,即初始元素的个数和删除的元素个数。
以下n行每行包含一个1到n之间的正整数,即初始排列。
以下m行每行一个正整数,依次为每次删除的元素。
N<=100000 M<=50000

Output

输出包含m行,依次为删除每个元素之前,逆序对的个数。

Sample Input

5 4
1
5
3
4
2
5
1
4
2

Sample Output

5
2
2
1

HINT

样例解释
(1,5,3,4,2)?(1,3,4,2)?(3,4,2)?(3,2)?(3)。

Solution

树套树,树状数组套主席树
首先看问题
我们预处理出\(A1[i]\)\(i\) 之前的位置上的数比 \(i\) 位置上的数大的个数),\(A2[i]\)\(i\) 之后的位置上的数比 \(i\) 位置上的数小的个数),顺便求一下最开始的逆序对
那么我们每次删除一个数 \(x\) ,它在数列中的位置是 \(i\) ,那么它对答案产生的影响就是使答案减小 \(A1[i]+A2[i]-Mquery(i)-Lquery(i)\)
其中 \(Mquery(i)\) 表示的是 \(i\) 位置之前的已经被删除了的权值比 \(i\) 位置上的权值大的个数,\(Lquery(i)\) 表示的就是后面的比它小的已经删除了的个数
既然 \(A1\)\(A2\) 已经预处理好了
那么我们需要维护的就是两个查询了
我们想,假如没有修改,那么两个查询直接用主席树找就行了
那么有修改呢,我们需要为主席树提供的就是前缀和
所以就用树状数组去维护前缀和,类似于 BZOJ 1901 Zju2112 Dynamic Rankings 用一个树套树,这道题就搞定了

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ld long double
#define left 0
#define right 1
#define Mid ((l+r)>>1)
#define lson l,Mid
#define rson Mid+1,r
const int MAXN=100000+10;
int n,m,A[MAXN],A1[MAXN],A2[MAXN],pos[MAXN];
ll ans=0;
struct BI_Tree{
    int C[MAXN];
    inline void init()
    {
        memset(C,0,sizeof(C));
    }
    inline int lowbit(int x)
    {
        return x&(-x);
    }
    inline int sum(int x)
    {
        int res=0;
        while(x>0)
        {
            res+=C[x];
            x-=lowbit(x);
        }
        return res;
    }
    inline void add(int x,int k)
    {
        while(x<=n)
        {
            C[x]+=k;
            x+=lowbit(x);
        }
    }
};
BI_Tree BIT;
struct ChairManTree_BIT{
    int cnt,lc[MAXN*50],rc[MAXN*50],root[MAXN],nt[2],need[2][MAXN];
    ll num[MAXN*50];
    inline void init()
    {
        cnt=0;
        memset(lc,0,sizeof(lc));
        memset(rc,0,sizeof(rc));
        memset(num,0,sizeof(num));
    }
    inline int lowbit(int x)
    {
        return x&(-x);
    }
    inline void Insert(int &rt,int l,int r,int pos)
    {
        if(!rt)rt=++cnt;
        num[rt]++;
        if(l==r)return ;
        else
        {
            if(pos<=Mid)Insert(lc[rt],lson,pos);
            else Insert(rc[rt],rson,pos);
        }
    }
    inline void add(int x,int k)
    {
        while(x<=n)
        {
            Insert(root[x],1,n,k);
            x+=lowbit(x);
        }
    }
    inline void Gneed(int nxt[])
    {
        for(register int i=1;i<=nt[left];++i)need[left][i]=nxt[need[left][i]];
        for(register int i=1;i<=nt[right];++i)need[right][i]=nxt[need[right][i]];
    }
    inline int Lquery(int l,int r,int k)
    {
        if(l==r)return 0;
        else
        {
            ll res=0;
            if(k>Mid)
            {
                for(register int i=1;i<=nt[right];++i)res+=num[lc[need[right][i]]];
                for(register int i=1;i<=nt[left];++i)res-=num[lc[need[left][i]]];
                Gneed(rc);
                res+=Lquery(rson,k);
            }
            else
            {
                Gneed(lc);
                res+=Lquery(lson,k);
            }
            return res;
        }
    }
    inline ll Mquery(int l,int r,int k)
    {
        if(l==r)return 0;
        else
        {
            ll res=0;
            if(k<=Mid)
            {
                for(register int i=1;i<=nt[right];++i)res+=num[rc[need[right][i]]];
                for(register int i=1;i<=nt[left];++i)res-=num[rc[need[left][i]]];
                Gneed(lc);
                res+=Mquery(lson,k);
            }
            else
            {
                Gneed(rc);
                res+=Mquery(rson,k);
            }
            return res;
        }
    }
    inline ll sum(int l,int r,int k,int opt)
    {
        nt[left]=nt[right]=0;
        l--;
        while(l>0)
        {
            need[left][++nt[left]]=root[l];
            l-=lowbit(l);
        }
        while(r>0)
        {
            need[right][++nt[right]]=root[r];
            r-=lowbit(r);
        }
        if(opt==0)return Lquery(1,n,k);
        else return Mquery(1,n,k);
    }
};
ChairManTree_BIT T;
template<typename T> inline void read(T &x)
{
    T data=0,w=1;
    char ch=0;
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')w=-1,ch=getchar();
    while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
    x=data*w;
}
template<typename T> inline void write(T x,char c='\0')
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)write(x/10);
    putchar(x%10+'0');
    if(c!='\0')putchar(c);
}
template<typename T> inline void chkmin(T &x,T y){x=(y<x?y:x);}
template<typename T> inline void chkmax(T &x,T y){x=(y>x?y:x);}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
inline void init()
{
    BIT.init();
    for(register int i=1;i<=n;++i)
    {
        A1[i]=BIT.sum(n)-BIT.sum(A[i]);
        ans+=A1[i];
        BIT.add(A[i],1);
    }
    BIT.init();
    for(register int i=n;i>=1;--i)
    {
        A2[i]=BIT.sum(A[i]-1);
        BIT.add(A[i],1);
    }
}
int main()
{
    read(n);read(m);
    for(register int i=1;i<=n;++i)
    {
        read(A[i]);
        pos[A[i]]=i;
    }
    init();
    T.init();
    while(m--)
    {
        write(ans,'\n');
        int x;
        read(x);
        ans-=(A1[pos[x]]+A2[pos[x]]-T.sum(1,pos[x]-1,x,1)-T.sum(pos[x]+1,n,x,0));
        T.add(pos[x],x);
    }
    return 0;
}

以上是关于刷题BZOJ 3295 [Cqoi2011]动态逆序对的主要内容,如果未能解决你的问题,请参考以下文章

[BZOJ3295][Cqoi2011]动态逆序对

BZOJ#3295. [Cqoi2011]动态逆序对

bzoj3295: [Cqoi2011]动态逆序对

bzoj3295[Cqoi2011]动态逆序对 树套树

[BZOJ3295][Cqoi2011]动态逆序对

BZOJ3295: [Cqoi2011]动态逆序对