看节目

Description

?　　大概就是给定你一种用两个参数\(X\)和\(Y\)随机一个\(1\sim n\)的排列\(p\)的方式，然后给定一个数组\(a\)，现在有两种操作：

?　　操作\((1,k)\)表示进行\(k\)次重新排列，一次重新排列指的是令新的\(a\)中第\(p_i\)个位置的值等于原来\(a\)中的第\(i\)个位置的值

?　　操作\((2,l,r)\)表示查询\(\sum\limits_{i=l}^r a_i\)，答案对\(998244353\)取模

?　　数据范围：\(1\leq n,m\leq 10^5,233\leq X,Y<998244353,0\leq a_i<998244353,1\leq k\leq 10^9\)

?　　

Solution

?　　emmm好像第一次碰到这么神秘的分块题qwq记录一下（流下了做题少的泪水qwq）

?　　

??　　考虑一下随机出来的置换\(p\)的性质

?　　我们考虑将这个置换拆成若干个环（\(i\rightarrow p_i\)），记\(h_n\)表示长度为\(n\)的排列的期望环数，考虑从\(h_{n-1}\)推到\(h_n\)，那么第\(n\)个元素有\(\frac{1}{n}\)的概率自环，其余情况并入前面的环中，不会增加环数，于是有\(h_n=h_{n-1}+\frac{1}{n}\)，调和级数，渐进\(O(logn)\)

?　　我们将询问差分一下，这样就变成了若干个前缀和的询问，形如\((x,k)\)，表示的是查询重新排列了\(k\)次之后的前缀\(x\)的和，而拆成环之后重新排列其实就相当于在环上面跳（注意是反着跳）

?　　因为环数有保证，所以我们可以考虑对于每个环单独计算贡献：对于一个环\(i\)，记\(len_i\)该环的长度，\(val_i\)表示该环中的元素破成链之后的结果（下标从\(0\)开始），\(loc_i(k)\)表示重排\(k\)次之后\(i\)的位置，\(f_{i,k}(x)\)表示环\(i\)重排了\(k\)次之后的前缀和，那么有：
\[ f_{i,k}(x)=\sum\limits_{i=0}^{len-1}val_i[loc_i(k)\%len_i\leq x] \]
??　　这个时候就有一个很神秘的做法了：考虑对\(x\)进行分块，我们把所有的询问\((x,k)\)离线（其实在线好像也可以，只是分块维护的数组多一维。。？），按照询问的\(x\)排序，然后一块一块地处理，对于一个\(St\sim Ed\)的块，处理所有满足\(St\leq x\leq Ed\)的询问

?　　这样的话我们就需要维护一个数组\(sum[i][j]\)，假设当前已经处理完的最后一个块的结尾为\(ed\)，那么\(sum[i][j]\)表示第\(i\)个环重排了\(ed\)次之后前\(j\)位的和（也就是\(sum[i][j]=\sum\limits_{i}f_{i,ed}(j)\)），那么对于一个查询\((x,k)\)，我们枚举每一个环，将\(sum[i][k\%len_i]\)加入贡献，然后再暴力枚举一下当前块的开始位置\(st\sim x\)的每个位置，计算重排\(k\)次之后这些位置的值的和再加入贡献中即可

?　　那么最后的问题就是怎么计算\(sum[i][j]\)，我们每处理完一个块中的询问之后，都要将\(ed\)移动到这个块的结尾并重新计算\(sum\)，注意到\(f_{i,k}(x)\)其实是一个卷积形式，所以直接NTT就好了（然而实际上因为\([(i+k)\% len_i\leq x]\in \{0,1\}\)，所以直接FFT最后再取模好像也没有什么问题，会快）

??　　

?　　时间复杂度的话，记块大小为\(T\)，那么是\(O(\frac{n}{T}nlogn+Tn)\)的，然后当\(T\)取\(\sqrt{nlogn}\)的时候复杂度为\(O(n\sqrt{nlogn})\)的

?　　

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#define pb push_back
#define ll long long
using namespace std;
const int N=1e5+10,MOD=998244353;
struct Q{
    int x,id,op;
    ll k;
    Q(int _x=0,int _id=0,int _op=0,ll _k=0){x=_x; id=_id; op=_op; k=_k;}
    friend bool operator < (Q x,Q y){return x.x<y.x;}
}recq[N*2];
vector<int> cir[N];
int len[N],bl[N],loc[N];
int a[N],ans[N],p[N];
int n,m,X,Y;
int cntq,cntcir;
ll K;
int mul(int x,int y){return 1LL*x*y%MOD;}
int plu(int x,int y){y+=y<0?MOD:0; return (1LL*x+y)-(1LL*x+y>=MOD?MOD:0);}
int ksm(int x,int y){
    int ret=1,base=x;
    for (;y;y>>=1,base=mul(base,base))
        if (y&1) ret=mul(ret,base);
    return ret;
}
namespace NTT{/*{{{*/
    const int TOP=18,N=(1<<TOP)+10,G=3;
    int A[N],B[N],W[TOP+1][N][2];
    int rev[N];
    int n,len,invlen;
    void init(){
        int invg=ksm(G,MOD-2);
        int x,invx;
        for (int step=2,lg=1;step<N;step<<=1,++lg){
            x=ksm(G,(MOD-1)/step);
            invx=ksm(x,MOD-2);
            W[lg][0][0]=W[lg][0][1]=1;
            for (int i=1;i<(step>>1);++i){
                W[lg][i][0]=mul(W[lg][i-1][0],x);
                W[lg][i][1]=mul(W[lg][i-1][1],invx);
            }
        }
    }
    void getlen(int n){
        for (int i=0;i<len;++i) A[i]=B[i]=0;
        int bit=0;
        for (len=1;len<=n;len<<=1,++bit);
        rev[0]=0;
        for (int i=1;i<=len;++i) rev[i]=(rev[i>>1]>>1)|((i&1)<<(bit-1));
        invlen=ksm(len,MOD-2);
    }
    void ntt(int *a,int op){
        int u,v;
        for (int i=0;i<len;++i) if (rev[i]>i) swap(a[i],a[rev[i]]);
        for (int step=2,lg=1;step<=len;step<<=1,++lg)
            for (int st=0;st<len;st+=step)
                for (int i=0;i<(step>>1);++i){
                    v=mul(a[st+i+(step>>1)],W[lg][i][op==-1]);
                    u=a[st+i];
                    a[st+i]=plu(u,v);
                    a[st+i+(step>>1)]=plu(u,MOD-v);
                }
        if (op==1) return;
        for (int i=0;i<len;++i) a[i]=mul(a[i],invlen);
    }
    void calc(){
        ntt(A,1);
        ntt(B,1);
        for (int i=0;i<len;++i) A[i]=mul(A[i],B[i]);
        ntt(A,-1);
    }
}/*}}}*/
namespace Block{/*{{{*/
    const int LG=30;
    int sum[LG][N];
    int sq,num;
    int st,ed;
    int Id(int x){return (x-1)/sq+1;}
    int St(int x){return (x-1)*sq+1;}
    int Ed(int x){return min(n,x*sq);}
    int query(int x,ll k){
        int ret=0,id=Id(x),pos;
        for (int i=1;i<=cntcir;++i)
            ret=plu(ret,sum[i][k%len[i]]);
        int which;
        for (int i=st;i<=x;++i){
            which=bl[i];
            pos=(loc[i]-k%len[which]+len[which])%len[which];
            ret=plu(ret,a[cir[which][pos]]);
        }
        return ret;
    }
    void solve(){
        int now=1,tmp,x;
        sq=sqrt(n*log(n)/log(2.0));
        num=Id(n);
        for (int id=1;id<=num;++id){
            st=St(id); ed=Ed(id);
            while (now<=cntq&&recq[now].x<=ed){
                if (now==cntq)
                    int debug=1;
                tmp=query(recq[now].x,recq[now].k);
                ans[recq[now].id]=plu(ans[recq[now].id],tmp*recq[now].op);
                ++now;
            }
            if (now>cntq) break;

            for (int i=1;i<=cntcir;++i){
                NTT::getlen(len[i]*2);
                for (int j=0;j<len[i];++j) NTT::A[j+1]=a[cir[i][(len[i]-1)-j]];
                for (int j=0;j<len[i];++j) NTT::B[j]=(cir[i][j]<=ed);
                NTT::calc();
                for (int j=0;j<len[i];++j) 
                    sum[i][j]=plu(NTT::A[j],NTT::A[j+len[i]]);
            }
        }
        int debug=1;
    }
}/*}}}*/
int myrand(int l,int r){
    X=1LL*X*Y%MOD;
    return X%(r-l+1)+l;
}
void make_per(int *p,int n){
    for (int i=1;i<=n;++i){
        p[i]=i;
        swap(p[myrand(1,i)],p[i]);
    }
}
void prework(){
    int tmp;
    cntcir=0;
    for (int i=1;i<=n;++i){
        if (bl[i]) continue;
        ++cntcir; tmp=-1;
        while (!bl[i]){
            bl[i]=cntcir; loc[i]=++tmp;
            cir[cntcir].pb(i);
            i=p[i];
        }
        len[cntcir]=cir[cntcir].size();
    }
}
int read(){
    int ret=0; char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while ('0'<=ch&&ch<='9') ret=ret*10+ch-'0',ch=getchar();
    return ret;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("a.in","r",stdin);
#endif
    int op,x,l,r,tmpcnt=0;
    cntq=0;
    NTT::init();
    n=read(); m=read(); X=read(); Y=read();
    make_per(p,n);
    for (int i=1;i<=n;++i) a[i]=read();
    cntq=0; K=0;
    prework();
    for (int i=1;i<=m;++i){
        op=read();
        if (op==1)
            K+=read();
        else{
            l=read(); r=read();
            ++tmpcnt;
            recq[++cntq]=Q(l-1,tmpcnt,-1,K);
            recq[++cntq]=Q(r,tmpcnt,1,K);
        }
    }
    sort(recq+1,recq+1+cntq);
    Block::solve();
    for (int i=1;i<=(cntq+1>>1);++i) printf("%d\n",ans[i]);
}

看节目

标签：query   min   namespace   tchar   end   else   mat   row   pre   

原文地址：https://www.cnblogs.com/yoyoball/p/10261974.html