Preface

最後一題我一直覺得用莫隊是最好的。

數列分塊入門 7——區間乘法，區間加法，單點詢問

還是很簡單的吧，比起數列分塊入門 7就多了個區間乘。

類似於線段樹，由於乘法的優先級高於加法，因此我們先乘後加。

具體的，我們對於每一個塊再額外維護一個乘法標記，每次乘法時同時更新乘法/加法標記。

CODE

#include<cstdio>
#include<cctype>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=100005,BLO=320,mod=10007;
int n,a[N],blk[N],opt,x,y,z,add[BLO],mul[BLO],sum[BLO],size;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; int flag=1; while (!isdigit(ch=tc())) flag=ch^‘-‘?1:-1;
    while (x=(x<<3)+(x<<1)+ch-‘0‘,isdigit(ch=tc())); x*=flag;
}
inline void write(int x)
{
    if (x<0) putchar(‘-‘),x=-x;
    if (x>9) write(x/10); putchar(x%10+‘0‘);
}
inline void inc(int &x,int y)
{
    if ((x+=y)>=mod) x-=mod;
}
inline int query(int x)
{
    return (1LL*a[x]*mul[blk[x]]+add[blk[x]])%mod;
}
inline void reset(int id)
{
    for (register int i=(id-1)*size+1;i<=min(id*size,n);++i)
    a[i]=a[i]*mul[id]%mod,inc(a[i],add[id]);
    mul[id]=1; add[id]=0;
}
inline void modify_add(int l,int r,int x)
{
    register int i;
    for (reset(blk[l]),i=l;i<=min(blk[l]*size,r);++i) inc(a[i],x);
    if (blk[l]!=blk[r]) for (reset(blk[r]),i=(blk[r]-1)*size+1;i<=r;++i) inc(a[i],x);
    for (i=blk[l]+1;i<=blk[r]-1;++i) inc(add[i],x);
}
inline void modify_mul(int l,int r,int x)
{
    register int i;
    for (reset(blk[l]),i=l;i<=min(blk[l]*size,r);++i) a[i]=a[i]*x%mod;
    if (blk[l]!=blk[r]) for (reset(blk[r]),i=(blk[r]-1)*size+1;i<=r;++i) a[i]=a[i]*x%mod;
    for (i=blk[l]+1;i<=blk[r]-1;++i) mul[i]=(mul[i]+add[i])*x%mod,add[i]=x;
}
int main()
{
    //freopen("7.in","r",stdin); freopen("7.out","w",stdout);
    register int i; read(n); size=sqrt(n);
    for (fill(mul+1,mul+(n-1)/size+2,1),i=1;i<=n;++i)
    read(a[i]),inc(sum[blk[i]=(i-1)/size+1],a[i]);
    for (i=1;i<=n;++i)
    {
        read(opt); read(x); read(y); read(z);
        switch (opt)
        {
            case 0:modify_add(x,y,z);break;
            case 1:modify_mul(x,y,z);break;
            case 2:write(query(y)),putchar(‘\n‘);break;
        }
    }
    return 0;
}
 

數列分塊入門 8——區間詢問等於一個數 c 的元素，並將這個區間的所有元素改為 c

這個東西看一眼感覺就是除分塊不可的東西了。

我們還是維護一個整塊的標記，當這一塊內所有數的值都相同時我們直接得到值並且修改。

但是有一個很嚴重的問題，如果值不同怎麽辦？

沒事，我們直接遍歷整個塊即可，但是這樣不會T掉嗎？

我們要分析一波性質，我們發現詢問和修改是同時的，那麽說明在一次暴力統計塊後這個塊內的元素就有序了。

即便是後面的詢問打亂了順序也每次只需要\(O(\sqrt n)\)的復雜度遍歷即可

論分塊的玄學復雜度食用

CODE

#include<cstdio>
#include<cctype>
#include<cmath>
using namespace std;
const int N=100005,BLO=320;
int n,a[N],blk[N],mark[BLO],size,x,y,z;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-‘0‘,isdigit(ch=tc()));
}
inline void write(int x)
{
    if (x>9) write(x/10);
    putchar(x%10+‘0‘);
}
inline int min(int a,int b)
{
    return a<b?a:b;
}
inline void reset(int id)
{
    if (!mark[id]) return;
    for (register int i=(id-1)*size+1;i<=id*size;++i)
    a[i]=mark[id]; mark[id]=0;
}
inline int count(int id,int x)
{
    register int i,res=0;
    for (i=(id-1)*size+1;i<=id*size;++i)
    (a[i]==x&&++res),a[i]=x; mark[id]=x; return res;
}
inline int solve(int l,int r,int x)
{
    register int i,res=0;
    for (reset(blk[l]),i=l;i<=min(blk[l]*size,r);++i) (a[i]==x&&++res),a[i]=x;
    if (blk[l]!=blk[r]) for (reset(blk[r]),i=(blk[r]-1)*size+1;i<=r;++i) (a[i]==x&&++res),a[i]=x; 
    for (i=blk[l]+1;i<=blk[r]-1;++i)
    if (mark[i]) mark[i]==x&&(res+=size),mark[i]=x; else res+=count(i,x); return res;
}
int main()
{
    //freopen("8.in","r",stdin); freopen("8.out","w",stdout);
    register int i; read(n); size=sqrt(n);
    for (i=1;i<=n;++i)
    read(a[i]),blk[i]=(i-1)/size+1;
    for (i=1;i<=n;++i)
    read(x),read(y),read(z),write(solve(x,y,z)),putchar(‘\n‘);
    return 0;
}
 

數列分塊入門 9——詢問區間的最小眾數

這個看的題目的第一眼就感覺是莫隊板子題

不過莫隊的本質好像就是分塊吧，只不過是將詢問處理

那麽我們考慮一波對序列分塊的想法看看能不能搞。

首先離散化肯定少不了的（這裏懶了直接寫了map）

然後我們進行一波預處理，搞出每個塊到所有它之後的點的最小眾數即可出線個數

同時對於每一個離散過的數開一個vector記錄出現位置，之後開始搞

對於每一次詢問，我們對於所有整塊的操作可以直接利用預處理的東西求出答案

然後就是對於兩端不完整的塊中元素的出現個數了。我們枚舉每一個數，然後利用前面的vector，直接上二分找出現個數即可（我又懶了所有直接用了lower/upper_bound）

所以我就說莫隊好寫吧！

CODE

#include<cstdio>
#include<cctype>
#include<cmath>
#include<map>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=100005,BLO=320;
int n,a[N],blk[N],f[BLO][BLO],r[N],cnt[N],num[BLO][BLO],size,x,y,tot;
map <int,int> h;
vector <int> v[N];
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; while (!isdigit(ch=tc()));
    while (x=(x<<3)+(x<<1)+ch-‘0‘,isdigit(ch=tc()));
}
inline void write(int x)
{
    if (x>9) write(x/10);
    putchar(x%10+‘0‘);
}
inline void init(int s)
{
    memset(cnt,0,sizeof(cnt)); int ans=0,mx=0;
    for (register int i=(s-1)*size+1;i<=n;++i)
    {
        if (++cnt[a[i]]>mx||(cnt[a[i]]==mx&&r[a[i]]<r[ans])) mx=cnt[a[i]],ans=a[i];
        f[s][blk[i]]=ans;
    }
}
inline int find(int l,int r,int id)
{
    return upper_bound(v[id].begin(),v[id].end(),r)-lower_bound(v[id].begin(),v[id].end(),l);
}
inline int query(int L,int R)
{
    register int i; int ans=f[blk[L]+1][blk[R]-1],mx=find(L,R,ans);
    for (i=L;i<=min(blk[L]*size,R);++i)
    {
        int t=find(L,R,a[i]);
        if (t>mx||(t==mx&&r[a[i]]<r[ans])) mx=t,ans=a[i];
    }
    if (blk[L]!=blk[R]) for (i=(blk[R]-1)*size+1;i<=R;++i)
    {
        int t=find(L,R,a[i]);
        if (t>mx||(t==mx&&r[a[i]]<r[ans])) mx=t,ans=a[i];
    }
    return r[ans];
}
int main()
{
    //freopen("9.in","r",stdin); freopen("9.out","w",stdout);
    register int i; read(n); size=sqrt(n);
    for (i=1;i<=n;++i)
    {
        read(a[i]); blk[i]=(i-1)/size+1;
        if (!h[a[i]]) h[a[i]]=++tot; r[h[a[i]]]=a[i]; a[i]=h[a[i]];
        v[a[i]].push_back(i);
    }
    for (i=1;i<=blk[n];++i) init(i);
    for (i=1;i<=n;++i)
    read(x),read(y),write(query(x,y)),putchar(‘\n‘);
    return 0;
}

數列分塊入門九題（三）：LOJ6283~6285