【BZOJ 1129】[POI2008]Per 二叉堆

这个东西读完题之后,就能知道我们要逐位计算贡献.
推一下式子,会发现,这一位的贡献,是当前剩余的数字形成的序列的总数,乘上所剩数字中小于s上这一位的数的个数与所剩数字的总数的比.
所以我们维护“当前剩余的数字形成的序列的总数”以及权值数组的前缀和就好了.
后者可以用树状数组维护,前者可以用一个变量维护.
但是!!!!!模数不是质数!!!!!
这就很坑爹,网上的人基本上都是把模数质因数分解后,对于每一种质因数计算一次答案,最后再crt计算答案.
然而,作为一只**,我用长得像二叉堆,但是维护信息上又有点像平衡树的二叉树维护变量,直接以m为模数计算出答案.
我的思路是这样的,我们维护数字,只有乘和除,既然不能算逆元,那么我们就维护这个数字的所有可能含有的质数的个数,并且对于所有的质数建立树形结构,每个点除了维护其自己信息以外,还维护了其子树乘积,那么树根的子树乘积就是这个数,而我们乘(除)一个数的时候,将乘(除)的数质因子拆分,对于每个质因子,修改他在树中的信息以及他的在树中的祖先的信息,这样的复杂度是O(nlog^2n)的.
一开始我直接按照质数的大小建立BST,卡了半天常数才过,后来发现,我不如按照质数大小建立小根堆,这样使用频繁的质数(小的质数)的深度就会变小,于是我一下子从bzoj倒数第一滚到大众时间.

#include <cstdio>
#include <cstring>
#include <algorithm>
#define R register
typedef long long LL;
char xB[(<<)+],*xS,*xT;
#define gtc (xS==xT&&(xT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xT)?0:*xS++)
inline void read(int &x){
  R char ch=gtc;
  for(x=;ch<''||ch>'';ch=gtc);
  for(;ch>=''&&ch<='';x=(x*)+ch-'',ch=gtc);
}
const int N=;
inline int gcd(int x,int y){return !x?y:gcd(y%x,x);}
int len,prime[N/+],min[N+],size[N/+];
bool isnot[N+];
int n,m,ans,P,lim;
int mii[N*+],*begin[N/+];
#define mi(a,b) (*(begin[(a)]+(b)))
int a[N+],tree[N+],cnt[N+];
inline void U(R int pos,int key){
  for(;pos<=N;pos+=pos&(-pos))
    tree[pos]+=key;
}
inline int Q(R int pos){
  R int ret=;
  for(;pos>;pos-=pos&(-pos))
    ret+=tree[pos];
  return ret;
}
inline void get(R int x,int opt){
  while(min[x])
    size[min[x]]+=opt,x/=prime[min[x]];
}
struct BST{
  BST *ch[],*f;
  int id,key;
}node[N+],*root;
#define pushup(p) (p->key=(LL)mi(p->id,size[p->id])*p->ch[0]->key%P*p->ch[1]->key%P)
#define mid ((l+r)>>1)
inline void build(BST *&p,BST *fa,int id){
  p=node+id,p->key=;
  if(id>len)return;
  p->f=fa,p->id=id;
  build(p->ch[],p,id<<);
  build(p->ch[],p,(id<<)|);
  pushup(p);
}
inline void update(int x){
  R BST *p=node+x;
  while(p)pushup(p),p=p->f;
}
inline void update(R int x,int opt){
  if(x==)return;
  R int last=;
  while(min[x]){
    size[min[x]]+=opt;
    if(last&&min[x]!=last)update(last);
    last=min[x];
    x/=prime[min[x]];
  }
  update(last);
}
int main(){
  //freopen("rio.in","r",stdin);
  R int i,j;
  read(n),read(P),lim=n;
  isnot[]=true,min[]=;
  for(i=;i<=lim;++i){
    if(!isnot[i])prime[++len]=i,min[i]=len;
    for(j=;prime[j]*i<=lim;++j){
      isnot[prime[j]*i]=true;
      min[prime[j]*i]=j;
      if(i%prime[j]==)break;
    }
  }
  for(i=;i<=n;++i)read(a[i]),U(a[i],),++cnt[a[i]];
  for(i=;i<=n;++i)get(i,);
  for(i=;i<=len;++i){
    begin[i]=mii+m;
    m+=size[i]++;
    mi(i,)=;
    for(j=;j<=size[i]+;++j)
      mi(i,j)=(LL)mi(i,j-)*prime[i]%P;
  }
  for(i=;i<=N;++i)
    for(j=;j<=cnt[i];++j)
      get(j,-);
  build(root,NULL,);
  R int s;
  for(i=;i<=n;++i){
    s=Q(a[i])-cnt[a[i]];
    if(s){
      update(s/gcd(s,n-i+),),update((n-i+)/gcd(s,n-i+),-);
      ans=(ans+root->key)%P;
      update(cnt[a[i]],),update(s,-);
    }else{
      update(cnt[a[i]],),update(n-i+,-);
    }
    --cnt[a[i]],U(a[i],-);
  }
  ans=(ans+)%P;
  printf("%d\n",ans);
  return ;
}