莫队专题

https://blog.csdn.net/qq_41552508/article/details/100556943附上学习连接

以防万一还是搬出来吧

一、适用问题

莫队算法是一种离线算法，用分块去优化暴力，不包含修改的话，复杂度为 0的二分之三。

莫队的算法是不断扩大区间的。

三、普通莫队习题

1. [2009国家集训队] 小Z的袜子

题意: n nn 双颜色不同袜子，m mm 次询问，每次询问给出 [L,R] [L,R][L,R] 区间，询问在 [L,R] [L,R][L,R] 区间中随机抽出两双颜色相同的袜子的概率，输出最简分数形式 (A/B) (A/B)(A/B)。

我们所记录的是x双同色袜子的组合方案数所以我们除以他的区间内袜子的c（n，2）就是答案了

分析到这里，就可以发现这是一道普通莫队的裸题，我们添加与删除时只需加上或减去当前与该点颜色相同的袜子数，这样同时可以避免重复计算。

代码:

#include <bits/stdc++.h>

#define rep(i,a,b) for(int i = a; i <= b; i++)

typedef long long ll;

const int N = 2*1e5+100;

using namespace std;

int a[N],pos[N],n,m,L,R;

ll ans[N][2],flag[N],Ans;

struct Node{

int l,r,id;

bool operator < (Node xx) const{

if(pos[l] == pos[xx.l]) return r < xx.r;

else return pos[l] < pos[xx.l];

}

}Q[N];

ll gcd(ll a,ll b) {return b == 0 ? a:gcd(b,a%b);}

void add(int x){

Ans += flag[a[x]];

flag[a[x]]++;

}

void del(int x){

flag[a[x]]--;

Ans -= flag[a[x]];

}

int main()

{

L = 1, R = 0;

scanf("%d%d",&n,&m);

int sz = sqrt(n);

rep(i,1,n){

scanf("%d",&a[i]);

pos[i] = i/sz;

}

rep(i,1,m){

scanf("%d%d",&Q[i].l,&Q[i].r);

Q[i].id = i;

}

sort(Q+1,Q+1+m);

rep(i,1,m){

while(L < Q[i].l) del(L),L++;

while(L > Q[i].l) L--, add(L);

while(R < Q[i].r) R++, add(R);

while(R > Q[i].r) del(R), R--;

ll len = Q[i].r-Q[i].l+1;

ll tp = len*(len-1ll)/(ll)2;

ll g = gcd(Ans,tp);

ans[Q[i].id][0] = Ans/g;

ans[Q[i].id][1] = tp/g;

}

rep(i,1,m) printf("%lld/%lld\n",ans[i][0],ans[i][1]);

return 0;

}

2. 花神的嘲讽计划Ⅰ

题意: 初始序列长度为 n nn，m mm 组询问，每次询问给出一个 x xx、y yy，以及长度为 k kk 的连续序列。询问在区间 [x,y] [x,y][x,y] 中是否存在一段连续的长度为 k kk 的，与询问中给出的序列相同的一段序列。存在输出 No NoNo，不存在输出 Yes YesYes。(1≤n,m≤106) (1\leq n,m\leq 10^6)(1≤n,m≤10

)

思路: 这题可以观察到每次询问的连续序列长度都是固定为 k kk，因此不难想到用 hash hashhash 来解决这个问题。我们将每个位置后面连续的一段 k kk 哈希起来，然后每个位置就有了一个对应的 hash hashhash 值。我们将这些 hash hashhash 值离散化之后，用桶来记录区间端点移动时对答案的贡献。

代码:

#include <bits/stdc++.h>

#define rep(i,a,b) for(int i = a; i <= b; i++)

typedef long long ll;

const int N = 2*1e6+100;

const ll mod = 1e11+7;

using namespace std;

int n,m,k,L,R,flag[N],tot,ans[N],pos[N],pp[N];

ll a[N],b[N],ha[N];

struct Node{

int l,r,id;

ll w;

bool operator < (Node xx) const {

if(pos[l] != pos[xx.l]) return pos[l] < pos[xx.l];

else return r < xx.r;

}

}q[N];

int find(ll x){

return lower_bound(b+1,b+1+tot,x)-b;

}

ll Hash(int pos){

ll tp = 0;

ll base = 1;

rep(i,pos,pos+k-1){

tp = (tp+a[i]*base)%mod;

if(tp < 0) tp = (tp+mod)%mod;

base = (base*(ll)133)%mod;

if(base < 0) base = (base+mod)%mod;

}

return tp;

}

void add(int x) {flag[pp[x]]++;}

void del(int x) {flag[pp[x]]--;}

int main()

{

scanf("%d%d%d",&n,&m,&k);

rep(i,1,n) scanf("%lld",&a[i]);

rep(i,1,m){

int xx,yy; scanf("%d%d",&xx,&yy);

q[i].l = xx, q[i].r = yy, q[i].id = i;

q[i].r = q[i].r-k+1;

ll tp = 0;

ll base = 1;

rep(j,1,k){

ll hp; scanf("%lld",&hp);

tp = (tp+hp*base)%mod;

if(tp < 0) tp = (tp+mod)%mod;

base = (base*(ll)133)%mod;

if(base < 0) base = (base+mod)%mod;

}

q[i].w = tp;

b[++tot] = tp;

}

rep(i,1,n-k+1){

ll tp = Hash(i);

ha[i] = tp;

b[++tot] = tp;

}

sort(b+1,b+1+tot);

tot = unique(b+1,b+1+tot)-b-1;

rep(i,1,n-k+1){

pp[i] = find(ha[i]);

}

int sz = sqrt(n);

rep(i,1,n) pos[i] = i/sz;

sort(q+1,q+1+m);

L = 1, R = 0;

rep(i,1,m){

while(L < q[i].l) del(L), L++;

while(L > q[i].l) L--, add(L);

while(R < q[i].r) R++, add(R);

while(R > q[i].r) del(R), R--;

int pos = find(q[i].w);

if(flag[pos]) ans[q[i].id] = 1;

else ans[q[i].id] = 0;

}

rep(i,1,m){

if(ans[i]) printf("No\n");

else printf("Yes\n");

}

return 0;

}

3. XOR and Favorite Number

思路: 既然是某一区间的异或和，不难想到先求一个异或前缀和，然后对于一个 j jj 来说，就是询问区间 [l,r] 中有多少个 i i 满足 sum[i−1] ^ sum[j]=k。

问题拆解到这一步，剩下的问题就比较明了了，直接上莫队，然后用桶维护每一个数的异或前缀和即可。

代码:

#include <bits/stdc++.h>

#define rep(i,a,b) for(int i = a; i <= b; i++)

typedef long long ll;

const int N = 2*1e6+100;

using namespace std;

int a[N],pos[N],n,m,k,L,R;

ll ans[N],flag[N],Ans;

struct Node{

int l,r,id;

bool operator < (Node xx) const{

if(pos[l] == pos[xx.l]) return r < xx.r;

else return pos[l] < pos[xx.l];

}

}Q[N];

void add(int x){

Ans += flag[a[x]^k];

flag[a[x]]++;

}

void del(int x){

flag[a[x]]--;

Ans -= flag[a[x]^k];

}

int main()

{

L = 1, R = 0;

scanf("%d%d%d",&n,&m,&k);

int sz = sqrt(n);

rep(i,1,n){

scanf("%d",&a[i]);

a[i] = a[i]^a[i-1];

pos[i] = i/sz;

}

rep(i,1,m){

scanf("%d%d",&Q[i].l,&Q[i].r);

Q[i].id = i;

}

sort(Q+1,Q+1+m);

flag[0] = 1;

rep(i,1,m){

while(L<Q[i].l) del(L-1), L++;

while(L>Q[i].l) L--, add(L-1);

while(R<Q[i].r) R++, add(R);

while(R>Q[i].r) del(R), R--;

ans[Q[i].id] = Ans;

}

rep(i,1,m) printf("%lld\n",ans[i]);

return 0;

}

Chika and Friendly Pairs

问区间里有多少对i，j满足i<j,同时a[i]-a[j]的绝对值小于等于k；

由于 n nn 和 m mm 的范围比较小，可以考虑使用莫队分块算法，在加入和删除的地方使用树状数组统计答案即可。

代码:

#include <bits/stdc++.h>

#define mem(a,b) memset(a,b,sizeof a);

#define rep(i,a,b) for(int i = a; i <= b; i++)

#define per(i,a,b) for(int i = a; i >= b; i--)

#define __ ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;

typedef double db;

const int N = 27000+100;

const db EPS = 1e-9;

using namespace std;

void dbg() {cout << "\n";}

template<typename T, typename... A> void dbg(T a, A... x) {cout << a << ' '; dbg(x...);}

#define logs(x...) {cout << #x << " -> "; dbg(x);}

int n,m,k,a[N],b[3*N],tot,L,R,pos[N],now[N][3];

struct Node{

int l,r,id;

bool operator < (Node xx) const {

if(pos[l] == pos[xx.l]) return r < xx.r;

else return pos[l] < pos[xx.l];

}

}q[N];

ll c[3*N],ans[N],Ans;

inline int lowbit(int x) {return x&(~x+1);}

inline void update(int x,ll v) {for(;x<=tot;x+=lowbit(x)) c[x]+=v;}

inline ll ask(int x){

ll tp = 0;

while(x) tp += c[x], x -= lowbit(x);

return tp;

}

int find(int x){

return lower_bound(b+1,b+1+tot,x)-b;

}

void add(int x){

int p1 = now[x][1], p2 = now[x][2];

Ans += ask(p1)-ask(p2);

update(now[x][0],1);

}

void del(int x){

update(now[x][0],-1);

int p1 = now[x][1], p2 = now[x][2];

Ans -= ask(p1)-ask(p2);

}

int main()

{

L = 1, R = 0;

scanf("%d%d%d",&n,&m,&k);

int sz = sqrt(n);

rep(i,1,n){

scanf("%d",&a[i]);

b[++tot] = a[i]; b[++tot] = a[i]+k; b[++tot] = a[i]-k-1;

pos[i] = i/sz;

}

sort(b+1,b+1+tot);

tot = unique(b+1,b+1+tot)-b-1;

rep(i,1,n){

now[i][0] = find(a[i]);

now[i][1] = find(a[i]+k);

now[i][2] = find(a[i]-k-1);

}

rep(i,1,m){

scanf("%d%d",&q[i].l,&q[i].r);

q[i].id = i;

}

sort(q+1,q+1+m);

rep(i,1,m){

while(L < q[i].l){

del(L);

L++;

}

while(L > q[i].l){

L--;

add(L);

}

while(R < q[i].r){

R++;

add(R);

}

while(R > q[i].r){

del(R);

R--;

}

ans[q[i].id] = Ans;

}

rep(i,1,m) printf("%lld\n",ans[i]);

return 0;

}

5莫队求组合数前缀和

Harvest of Apples

求C(n,0)+C(n,1)+C(n,2)+.....+C(n,m);

设S(n,m)=C(n,0)+C(n,1)+C(n,2)+.....+C(n,m);

第一个式子易得，第二个式子：杨辉三角的c n,m=c(n-1,m)+c(n-1,m-1),利用这个我们来推出s（n,m)就有上面那样公式

那么就是这一行等于上一行的都用了2次，只有第最后一个用了一次

所以减去c（n-1，m）

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<algorithm>
using namespace std;
const int mod=1e9+7;
#define ll long long
const int maxn=1e5+7;
ll jiecheng[maxn],inv[maxn];
ll ans[maxn];
int block;
ll qsm(ll a,ll b)
{
    ll ans=1;
    while(b){
        if(b&1)
            ans=ans*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return ans;
}
void init()
{
    jiecheng[1] = 1;
    for(int i = 2; i < maxn; i++)
        jiecheng[i] = jiecheng[i-1] * i % mod;
    for(int i = 1; i < maxn; i++)
        inv[i] = qsm(jiecheng[i], mod-2);
}
struct node{
    int l,r;
    int i;
}modui[maxn];
bool cmp(node a,node b)
{
    if(a.l/block==b.l/block)
        return a.r<b.r;
    return a.l<b.l;
}
ll C(ll n,ll m)
{
     
    if(m == 0 || m == n) return 1;
    ll ans=1;
    ans=(jiecheng[n]*inv[m])%mod*inv[n-m];
    ans=ans%mod;
    return ans;
}
int main()
{
    init();
    block = sqrt(maxn);
    int t;
    scanf("%d",&t);
    for(int i=0;i<t;i++)
    {
        scanf("%d%d",&modui[i].l,&modui[i].r);
        modui[i].i=i;
    }
    sort(modui,modui+t,cmp);
    int l=1,r=0;
    int sum=1;
    for(int i = 0; i < t; i++)
    {
        while(l < modui[i].l) sum = (2 * sum - C(l++, r) + mod) % mod;
        while(l > modui[i].l) sum = ((sum + C(--l, r))*inv[2]) % mod;
        while(r < modui[i].r) sum = (sum + C(l, ++r)) % mod;
        while(r > modui[i].r) sum = (sum - C(l, r--) + mod) % mod;
        ans[modui[i].i] = sum;
    }
    for(int i=0;i<t;i++)
    {
        printf("%lld\n",ans[i]);
    }
     
    return 0;
}
 

~~~待修改莫队
1. Machine Learning
思路: 这个问题唯一的操作难点在于 mex mexmex 函数的求取，其实我们可以像求取 SG SGSG 函数的 mex mexmex 一样，直接暴力求取即可。然后其余部分就是常规的带修改莫队的操作了。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#define __ ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define rep(i,a,b) for(int i = a; i <= b; i++)
#define LOG1(x1,x2) cout << x1 << ": " << x2 << endl;
#define LOG2(x1,x2,y1,y2) cout << x1 << ": " << x2 << " , " << y1 << ": " << y2 << endl;
#define LOG3(x1,x2,y1,y2,z1,z2) cout << x1 << ": " << x2 << " , " << y1 << ": " << y2 << " , " << z1 << ": " << z2 << endl;
typedef long long ll;
typedef double db;
const int N = 2*1e5+100;
const int M = 1e5+100;
const db EPS = 1e-9;
using namespace std;

int n,qq,a[N],b[N],tot,Qnum,Cnum,pos[N],ans[N],L,R,T,flag[N],vis[N];
struct Query{
	int l,r,id,t;
	bool operator < (Query xx) const {
		if(pos[l] != pos[xx.l]) return pos[l] < pos[xx.l];
		else if(pos[r] != pos[xx.r]) return pos[r] < pos[xx.r];
		else return t < xx.t;
	}
}q[M];
struct Change{
	int pos,val;
}C[M];

int find(int x){
	return lower_bound(b+1,b+1+tot,x)-b;
}

void add(int x){
	if(flag[a[x]]!=0) vis[flag[a[x]]]--;
	flag[a[x]]++; vis[flag[a[x]]]++;
}

void del(int x){
	vis[flag[a[x]]]--; flag[a[x]]--;
	if(flag[a[x]] != 0) vis[flag[a[x]]]++;
}

void Work(int x,int i){
	if(C[x].pos >= q[i].l && C[x].pos <= q[i].r){
		vis[flag[a[C[x].pos]]]--; flag[a[C[x].pos]]--;
		if(flag[a[C[x].pos]] != 0) vis[flag[a[C[x].pos]]]++;
		if(flag[C[x].val] != 0) vis[flag[C[x].val]]--;
		flag[C[x].val]++; vis[flag[C[x].val]]++;
	}
	swap(a[C[x].pos],C[x].val);
}

int solve(){
	rep(i,0,n)
		if(!vis[i]) return i;
}

int main()
{
	scanf("%d%d",&n,&qq);
	rep(i,1,n){
		scanf("%d",&a[i]);
		b[++tot] = a[i];
	}
	rep(i,1,qq){
		int op,l,r; scanf("%d%d%d",&op,&l,&r);
		if(op == 1) Qnum++, q[Qnum] = {l,r,Qnum,Cnum};
		else C[++Cnum] = {l,r}, b[++tot] = r;
	}
	sort(b+1,b+1+tot);
	tot = unique(b+1,b+1+tot)-b-1;
	int sz = pow(n,0.66666666666666);
	rep(i,1,n) pos[i] = i/sz;
	sort(q+1,q+1+Qnum);
	L = 1, R = 0, T = 0;
	vis[0] = 1;
	rep(i,1,n) a[i] = find(a[i]);
	rep(i,1,Cnum) C[i].val = find(C[i].val);
	rep(i,1,Qnum){
		while(L < q[i].l) del(L++); 
		while(L > q[i].l) add(--L);
		while(R < q[i].r) add(++R);
		while(R > q[i].r) del(R--);
		while(T < q[i].t) Work(++T,i);
		while(T > q[i].t) Work(T--,i);
		ans[q[i].id] = solve();
	}
	rep(i,1,Qnum) printf("%d\n",ans[i]);
	return 0;
}

当我们按上述步骤把

我们当前处理出来的是询问(1,6)的答案，也就是这条黄色路径

我们下一个要求的是蓝色路径(2,4)的答案

这种情况下我们发现，其实每次增加的就是lca(1,2)到2，以及lca(4,6)到4的那些节点

同时lca(1,2)到1，以及lca(4,6)到6的路径上的节点要去掉

诶？

那岂不是可以求出两个lca，然后把这两对点路径上除了lca的点的状态都反过来就可以了？

是的就是这样，上代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
long long n,m,z[100005],k,b[100005],s,c[100005],h[100005],cnt,B,q,v[100005],w[100005],d[100005],f[25][100005],cc,cq,now,an,ans[100005],bj[100005],num[100005],g[100005];
struct ll
{
    long long nx;
    long long to;
}a[200005];
struct mdc
{
    long long p;
    long long x;
}mc[100005];
struct mdq
{
    long long u;
    long long v;
    long long t;
    long long id;
    bool operator<(mdq& y)
    {
    return b[u]==b[y.u]?(b[v]==b[y.v]?t<y.t:b[v]<b[y.v]):b[u]<b[y.u];
    }
}mq[100005];
void ad(long long x,long long y)
{
    a[++cnt].to=y;
    a[cnt].nx=h[x];
    h[x]=cnt;
}
void dfs(int u)
{
    int t=k;
    for (int i=h[u];i;i=a[i].nx)
    {
        int v=a[i].to;
        if (v!=f[0][u])
        {
            f[0][v]=u;
            d[v]=d[u]+1;
            dfs(v);
            if (k-t>=B)
            {
                ++s;
                while (k>t)
                b[z[k--]]=s;
            }
        }
    }
    z[++k]=u;
}
void qf(long long x)
{
    if(bj[x])
    an-=v[g[x]]*w[num[g[x]]--];
    else 
    an+=v[g[x]]*w[++num[g[x]]];
    bj[x]^=1;///就是这里，我们知道上图可知道我们更新的点如果已经标记过说明此时我们不需要把他加紧答案，所以减掉，没被标记过说明是我们需要新增的，所以此处利用位运算来标记
}
void xg(long long x)
{
    if(bj[mc[x].p])
    {
        qf(mc[x].p);
        swap(g[mc[x].p],mc[x].x);
        qf(mc[x].p);
    }
    else swap(g[mc[x].p],mc[x].x);
}
long long lca(long long x,long long y)//lca就不多说了
{
    long long i;
    if(d[x]<d[y])
    swap(x,y);
    for(i=0;i<=16;++i)
    if((d[x]-d[y])&(1<<i))
    x=f[i][x];
    if(x==y)
    return x;
    for(i=16;i>=0;--i)
    if(f[i][x]!=f[i][y])
    {
        x=f[i][x];
        y=f[i][y];
    }
    return f[0][x];
}
void qxg(long long x,long long y)
{
    if(d[x]<d[y])
    swap(x,y);
    while(d[x]>d[y])
    {
        qf(x);
        x=f[0][x];
    }
    while(x!=y)
    {
        qf(x);
        qf(y);
        x=f[0][x];
        y=f[0][y];
    }
}
int main()
{
    long long i,j,x,y,o,u=1,v1=1,l;
    scanf("%lld%lld%lld",&n,&m,&q);
    B=pow(n,0.666);
    for(i=1;i<=m;i++)
    scanf("%lld",&v[i]);
    for(i=1;i<=n;i++)
    scanf("%lld",&w[i]);
    for(i=1;i<n;i++)
    {
        scanf("%lld%lld",&x,&y);
        ad(x,y);
        ad(y,x);
    }
    dfs(1);
    while(k)
    b[z[k--]]=s;
    for(i=1;i<=16;i++)
    for(j=1;j<=n;j++)
    f[i][j]=f[i-1][f[i-1][j]];
    for(i=1;i<=n;i++)
    scanf("%lld",&g[i]);
    for(i=1;i<=q;i++)//带修莫队模版
    {
        scanf("%lld",&o);
        if(!o)
        {
            cc++;
            scanf("%lld%lld",&mc[cc].p,&mc[cc].x);
        }
        else 
        {
            scanf("%lld%lld",&mq[cq].u,&mq[cq].v);
            mq[cq].t=cc;
            mq[cq].id=cq;
            cq++;
        }
    }
    sort(mq,mq+cq);
    for(i=0;i<cq;i++)
    {
        qxg(u,mq[i].u);
        qxg(v1,mq[i].v);
        u=mq[i].u;
        v1=mq[i].v;
        while(now<mq[i].t)
        xg(++now);
        while(now>mq[i].t)
        xg(now--);
        l=lca(u,v1);///这里解释下为什么要这样，原因在于经过公共祖先会使祖先这个点状态没有发生改变，所以下面我们要更新一下这个点，记录进答案，那由于我们是这样更新，更新完就得再还原回去，也就是公共祖先我们是额外更新进去答案得
        qf(l);
        ans[mq[i].id]=an;
        qf(l);
    }
    for(i=0;i<cq;i++)
    printf("%lld\n",ans[i]);
    return 0;
}

 回滚莫队！！！
首先先说回滚莫队用来解决什么问题，

普通莫队最重要的辨别点在于可以 O(1) 的增加或删除节点，而回滚莫队的关键点在于只能 O(1) O(1)O(1) 的增加或者删除节点，增加或删除只能二者选其一。
————————————————

例如历史研究这道题（增加节点的）

考虑一般莫队，复杂度是 $O(n*\sqrt{n})$ ，但是这题要求区间最值，那，要维护区间最值的话，只能是再套个其他的数据结构，复杂度就变成了 $O(n*\sqrt{n}*log(n))$ ，没法再优化。我们可以想到一个区间更新最大值如果他的区间是扩大的，那我们可以o(1)更新这个最大值对吧例如一个区间找到最大值是x，现在扩大区间我们只需要把x和新元素进行比较就行，但是缩小的话我们就没办法了

那怎么办呢，要是l是每次递减的就好了，人为制造扩大区间把缩小区间弄掉

如果r在块外，l在块内，

例如

---|---L------|-----R-----

这样，r每次递增那就不管他和原来的莫队一样就行

l每次设置在下一块的开始位置，如下图

---|---L------|-----R-----

---|---L-----|^-----r-----

^是l的位置

这样每次l都是向块内移动的r每次都是向右移动的，就保证了区间的递增性

如果L和R都是在同一个块内怎么办，，

for暴力计算！！！！

观察l，每次移动到应该查询的位置（L），然后计算完答案后，再移动回去（下一块的开始位置）

这样，就是回滚莫队了，可以明显看到l是滚来~滚去~的

#include <bits/stdc++.h>
#define rep(i,a,b) for(int i = a; i <= b; i++)
typedef long long ll;
const int N = 2e5+100;
using namespace std;

int n,m,sz,pos[N],a[N],b[N],tot,val[N],xl[N],xr[N],cnt[N],L,R,_cnt[N],lastblock;
//Maxn - 左右端点控制的最大值，temp - 临时最大值
//cnt - 左右端点移动时计数，_cnt - 左右端点同块时的计数
ll ans[N],Maxn,temp;
struct Node{
	int l,r,id;
	bool operator < (Node xx) const {
		if(pos[l] == pos[xx.l]) return r < xx.r;
		else return pos[l] < pos[xx.l];
	}
}q[N];

void init(){
	scanf("%d%d",&n,&m); sz = sqrt(n);
	rep(i,1,n) {scanf("%d",&a[i]); b[++tot] = a[i];}
	rep(i,1,m) {scanf("%d%d",&q[i].l,&q[i].r); q[i].id = i;}
	sort(b+1,b+1+tot); tot = unique(b+1,b+1+tot)-b-1;
	rep(i,1,n) val[i] = lower_bound(b+1,b+1+tot,a[i])-b;
	rep(i,1,n){
		pos[i] = i/sz;
		xl[pos[i]] = (xl[pos[i]] == 0 || xl[pos[i]] > i) ? i : xl[pos[i]];
		xr[pos[i]] = (xr[pos[i]] < i) ? i : xr[pos[i]];
	}
	sort(q+1,q+1+m);
}	

inline ll add(int x){
	return (++cnt[val[x]])*(ll)b[val[x]];
}

inline void del(int x) {cnt[val[x]]--;}

void solve(){
	L = 1, R = 0, lastblock = -1;
	rep(i,1,m){
		if(pos[q[i].l] == pos[q[i].r]){
			ll temp = 0;
			rep(j,q[i].l,q[i].r) temp = max(temp,(++_cnt[val[j]])*(ll)b[val[j]]);
			rep(j,q[i].l,q[i].r) _cnt[val[j]]--;
			ans[q[i].id] = temp;
		}
		else{
			if(lastblock != pos[q[i].l]){
				while(L < xr[pos[q[i].l]]+1) del(L), L++;
				while(R > L-1) del(R), R--;
				Maxn = 0; lastblock = pos[q[i].l];
			}
			//Maxn为右半部分的最大值，不包含左端点所在块的情况
			while(R < q[i].r) R++, Maxn = max(Maxn,add(R));
			temp = Maxn;
			//temp从Maxn继承而来，表示整个区间的最大值
			while(L > q[i].l) L--, temp = max(temp,add(L));
			while(L < xr[pos[q[i].l]]+1) del(L), L++;
			ans[q[i].id] = temp;
		}
	}
}

int main()
{
	init();
	solve();
	rep(i,1,m) printf("%lld\n",ans[i]);
	return 0;
}
————————————————
版权声明：本文为CSDN博主「Gene_INNOCENT」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41552508/article/details/100556943

Rmq Problem / mex（删除节点的）

这道题和上面的增加区间相反，这道题是减少区间，你想想那个mex，肯定是区间减少可以o（1）更新答案，增大反而不行嘛

所以

不难发现，对于这个问题来说，删除节点可以 O(1) O(1)O(1) 的更新答案，但是增加节点后答案的变化难以确定，因此考虑采用删除节点形式的回滚莫队来解决这个问题。

删除节点的回滚莫队，就是区间长度不断缩小的情况。因此我们需要对每个查询的左端点所在块编号进行升序，对每个查询的右端点进行降序，这样可以保证右端点是不断递减的。

然后对于左右端点在同一个块中的情况，我们依然是暴力求取答案。而对于不在同一块中的情况，我们需要每次查询结束后都将左端点移动到查询左端点所在的块的左边界上，这样才能保证区间长度在不断缩小。

除了上述这些回滚莫队的共性点之外，我们还需要关注一些特性点。对于这个问题，我们需要在最开始将左右边界分别设置为 1 11 和 n ，这样的目的是保证区间长度是不断递减的。然后求取答案时，我们需要维护两部分答案，一部分是区间 [l,r]中完全包含左端点所在块的部分的答案，另一部分即为当前查询的结果。

保存第一部分答案的目的在于增加节点是不能 O(1) O(1)O(1) 维护答案的，因此左端点递增之后答案就会变化而且不能恢复，所以如果不保存第一部分的答案是不能直接继承到下一个查询的，具体细节看代码就能够理解。
————————————————
版权声明：本文为CSDN博主「Gene_INNOCENT」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41552508/article/details/100556943

#include <bits/stdc++.h>
#define rep(i,a,b) for(int i = a; i <= b; i++)
const int N = 2e5+100;
using namespace std;

int n,m,a[N],sz,pos[N],xl[N],xr[N],cnt[N],ans[N],_cnt[N],lastblock,L,R;
struct Node{
	int l,r,id;
	bool operator < (Node xx) const {
		if(pos[l] == pos[xx.l]) return r > xx.r;
		else return pos[l] < pos[xx.l];
	}
}q[N];

void init(){
	scanf("%d%d",&n,&m);
	rep(i,1,n) scanf("%d",&a[i]);
	rep(i,1,m) scanf("%d%d",&q[i].l,&q[i].r), q[i].id = i;
	rep(i,1,n)
		if(a[i]>2e5) a[i]=2e5+1;
	int sz = sqrt(n);
	rep(i,1,n){
		pos[i] = i/sz; //点i所在块
		xl[pos[i]] = xl[pos[i]] == 0 ? i : xl[pos[i]]; //pos[i]块的左端点
		xr[pos[i]] = xr[pos[i]] < i ? i : xr[pos[i]]; //pos[i]块的右端点
	}
	sort(q+1,q+1+m);
}

inline void add(int x){
	cnt[a[x]]++;
}

inline void del(int x,int& hp){
	cnt[a[x]]--;
	if(cnt[a[x]] == 0 && a[x] < hp) hp = a[x];
}

void solve(){
	L = 1, R = n, lastblock = -1;
	rep(i,1,n) cnt[a[i]]++;
	int minn = 0;
	while(cnt[minn]) minn++;
	int base_min = minn;
	rep(i,1,m){
		if(pos[q[i].l] == pos[q[i].r]){
			rep(j,q[i].l,q[i].r) _cnt[a[j]]++;
			int now = 0;
			while(_cnt[now]) now++;
			rep(j,q[i].l,q[i].r) _cnt[a[j]]--;
			ans[q[i].id] = now;
		}
		else{
			if(lastblock != pos[q[i].l]){
				//每一次进入新的块时，右端点都是直接到n的，因此区间只有左端点在递增，可以不断O(1)维护答案
				while(R < n) R++, add(R);
				while(L < xl[pos[q[i].l]]) del(L,base_min), L++;
				minn = base_min; lastblock = pos[q[i].l];
			}
			//minn为包含左端点整个块的答案，用于继承到后续查询
			while(R > q[i].r) del(R,minn), R--;
			//temp为查询的答案
			int temp = minn;
			while(L < q[i].l) del(L,temp), L++;
			while(L > xl[pos[q[i].l]]) L--, add(L);
			ans[q[i].id] = temp;
		}
	}
}

int main()
{
	init();
	solve();
	rep(i,1,m) printf("%d\n",ans[i]);
	return 0;
}

posted on 2019-10-02 23:38 师姐的迷弟阅读(215) 评论(0) 编辑收藏举报

刷新页面返回顶部

莫队专题

Chika and Friendly Pairs

Rmq Problem / mex（删除节点的）

导航

公告