值域分块进阶

前言

本博文讲述值域分块的进阶用法。由于博主很菜，所以遇到错误欢迎各位在评论区指出。

值域分块入门

模意义查询

Q1

每次给定二元组 \((x,y)\)、模数 \(m\)，以及一个区间 \([l,r]\)。求出有多少 \(i\in [l,r]\) 满足 \((a_i+x)\bmod m<(a_i+y)\bmod m\)。

A1

经过 简单的题意转化 我们发现其实是要维护一个集合：

• 插入一个数。

• 查询 \(\bmod m\) 意义下小于等于 \(k\) 的数。

然后先考虑 根号分治 来处理 \(m \leq \sqrt n\) 的情况，显然，可以暴力，那么 \(m > \sqrt n\) 怎么办？

我们发现 \(\bmod m\) 意义下的桶上 一个 区间可以转换成原桶上 \(\frac{n}{m}\) 个区间。

因此可以转化成桶上一共 \(n \sqrt n\) 个区间的查询与 \(n\) 各单点修改。

那么我们就可以用 \(O(1)\) 查询，\(O(\sqrt n)\) 修改的值域分块解决。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5+114;
struct Node{
    int x,y,M,id,f;//anser[id]+=f*v f = 1 or -1 
};
const int top = 100000;
const int B = 556;
vector<Node> A[maxn];//储存离线询问 
int a[maxn];
int anser[maxn];//输出答案 
struct block{
    int pre[1000];
}cnt[1000];
int cnt_pre[1001];
int ans[1001][1001];
int n,q;
inline void change(int x,int val){
    int sum = x/B;
    x%=B;
    if(x==0) sum--,x+=B;
    for(int i=x;i<=B;i++) {
        cnt[sum].pre[i]+=val;
    }
    for(int i=sum;i<=B;i++) cnt_pre[i]+=val;
}
inline int query(int l,int r){
    if(l>r) return 0;
    int lc=l/B;
    l%=B;
    int rc=r/B;
    r%=B;
    if(l==0) lc--,l+=B;
    if(r==0) rc--,r+=B;
    if(lc==rc) return cnt[lc].pre[r]-cnt[rc].pre[l-1];
    int res=0;
    res+=cnt[lc].pre[B]-cnt[lc].pre[l-1];
    res+=cnt[rc].pre[r];
    res+=cnt_pre[rc-1]-cnt_pre[lc];
    return res;
}
void set_add(int x){//向集合中插入 x 
    change(x,1);
    for(int j=1;j<B;j++){
        ans[j][x%j]++;
    }
}
inline int set_pre(int m,int k){//mod m 意义下小于等于 k 的数的数量 
    if(k<0) return 0;
    if(m<B)
    {
        int sum=0;
        for(int j=0;j<=k;j++){
            sum+=ans[m][j];
        }
        return sum;
    }
    else{
        int l=m,r=m+k,res=query(1,k);
        while(r<top){
            res+=query(l,r);
            l+=m;
            r+=m;
        }
        if(l<=top)
            res+=query(l,top);
        return res;
    }
}
inline int set_query(int m,int l,int r){//mod m \in [l,r]
    if(l>r||l<0||r<0) return 0;
    return set_pre(m,r)-set_pre(m,l-1);
}
void scan(){
    for(int i=1;i<=n;i++){
        set_add(a[i]);
        for(int j=0;j<A[i].size();j++){
            Node now = A[i][j];
            //处理询问 now
            if(now.x%now.M==now.y%now.M){
                anser[now.id]+=now.f*0;
            }
            else if(now.x%now.M>now.y%now.M){
                int l=now.M-now.x%now.M,r=now.M-now.y%now.M-1;
                anser[now.id]+=now.f*set_query(now.M,l,r);
            }
            else{
                int l=now.M-now.y%now.M,r=now.M-now.x%now.M-1;
                anser[now.id]+=now.f*(i-set_query(now.M,l,r));
            }

        }
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>q;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=q;i++){
        int l,r,x,y,m;
        cin>>l>>r>>x>>y>>m;
        Node R,L;
        R.f=1;
        R.id=i;
        R.M=m;
        R.x=x;
        R.y=y;
        A[r].push_back(R);
        L.f=-1;
        L.id=i;
        L.M=m;
        L.x=x;
        L.y=y;
        A[l-1].push_back(L);
    }//询问离线
    scan();
    for(int i=1;i<=q;i++) cout<<anser[i]<<'\n';
}

替代回滚莫队

我们发现，大部分回滚莫队为了达到删除困难，增加简单的目的都让你维护最大值，但是这个东西也可以用值域分块维护。

Q1

定义一棵树的 \(MAD\) 值为其出现次数大于等于两次的点权最大值，现在给出一棵树，对于每一条边，你要求出将其删除后形成的两棵新树的 \(MAD\) 值的最大值。

注意不是真正删掉边，询问间相互独立。

A1

把问题转化为询问区间 \([l,r]\) 中出现次数大于等于 \(2\) 以及 区间之外 出现次数大于等于 \(2\) 的数的最大值。

出现次数大于等于 \(2\) 十分好维护，真正不好维护的其实是 最大值。

但是假若我们把所有答案用一个集合存储，我们就会发现问题成了维护一个集合：

• 加入/删除一个数。

• 求出最大值。

因此考虑把所有数用一个桶存储，再在桶上分块（值域分块），块内记录出现次数最大值，就可以 \(O(\sqrt n)\) 地查询最大值。

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxsq = 500;
const int B = 317;
const int maxn = 2e5+114;
int sq;
vector<int> edge[maxn];
int dfn[maxn];//dfs 序列颜色 
int val[maxn];//点的颜色
int mx[maxn],mi[maxn];//子树内 dfs 序最大/最小值 
int num;//记录目前 dfs了多少点 
map< pair<int,int> ,int> edge_pos;//记录每条边的编号 
int id[maxn];//记录点 u-fa[u] 这条路径的编号 
int id_dfn[maxn];//dfs 序为 u 的 id[u] 
int anser[maxn];//记录答案 
int cnt[maxn][2];//序列 内/外 出现次数
map<int,int> lsh;//离散化后映射回来 
int n;
inline int pmap(int x){
    return x/B;
}
inline int Lmap(int x){
    return x*B;
}
inline int Rmap(int x){
    return (x+1)*B-1;
}
class Node{
    private:
        int bl_cnt[maxsq];
        int cnt[maxn];
    public:
        inline void add(int x);
        inline void del(int x);
        inline int query();
}chifan;
inline void Node::add(int x){
    int bl=pmap(x);
    cnt[x]++;
    bl_cnt[bl]++;
}
inline void Node::del(int x){
    int bl=pmap(x);
    cnt[x]--;
    bl_cnt[bl]--;
}
inline int Node::query(){
    for(int i=B+3;i>=0;i--){
        if(bl_cnt[i]>0){
            int L=Lmap(i),R=Rmap(i);
            for(int j=R;j>=L;j--){
                if(cnt[j]>0) return j;
            }
        }
    }
    return -1;
}
inline void add(int x){
    if(cnt[x][1]==2){
        chifan.del(x);
    }
    cnt[x][0]++;
    cnt[x][1]--;
    if(cnt[x][0]==2){
        chifan.add(x);
    }
}
inline void del(int x){
    if(cnt[x][0]==2){
        chifan.del(x);
    }
    cnt[x][0]--;
    cnt[x][1]++;
    if(cnt[x][1]==2){
        chifan.add(x);
    }
}
map<int,int> lwx;//反向映射 
inline void dfs(int u,int fa){
    id[u]=edge_pos[make_pair(max(u,fa),min(u,fa))];
    mi[u]=mx[u]=++num;
    lwx[num]=u;
    id_dfn[num]=id[u];
    dfn[num]=val[u];
    for(int v:edge[u]){
        if(v==fa) continue;
        dfs(v,u);
        mx[u]=max(mx[u],mx[v]);
    }
}
struct Query{
    int l,r,id;//存储询问：左右端点以及编号 
}q[maxn];
inline bool cmp(Query a, Query b){
    return (a.l/sq)==(b.l/sq) ? a.r<b.r : a.l<b.l;
}
inline void work(){
    for(int i=1;i<=n;i++){
        q[i].id=id_dfn[i];
        q[i].l=mi[lwx[i]];
        q[i].r=mx[lwx[i]];
        //初始化出现次数 
        cnt[dfn[i]][1]++;
        if(cnt[dfn[i]][1]==2){
            chifan.add(dfn[i]);
        }
    }
    sort(q+1,q+n+1,cmp);
    int l=1,r=1;
    add(dfn[1]);
    for(int i=1;i<=n;i++){
        while(r<q[i].r){
            r++;
            add(dfn[r]);
        }
        while(l>q[i].l){
            l--;
            add(dfn[l]);
        }
        while(r>q[i].r){
            del(dfn[r]);
            r--;
        }
        while(l<q[i].l){
            del(dfn[l]);
            l++;
        }
        anser[q[i].id]=lsh[chifan.query()];
    }
}
inline void edge_add(int u,int v,int pos){
    edge[u].push_back(v);
    edge[v].push_back(u);
    edge_pos[make_pair(max(u,v),min(u,v))]=pos;
}
inline void init(){
    cin>>n;
    sq=sqrt(n);
    for(int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        edge_add(u,v,i);
    }
    vector< pair<int,int> > wyb;//val:id
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        wyb.push_back(make_pair(x,i));
    }
    sort(wyb.begin(),wyb.end());
    int last=1;
    for(int i=0;i<wyb.size();i++){
        if(wyb[i].first!=wyb[last].first){
            last=i;
        }
        val[wyb[i].second]=(last+1);
        lsh[(last+1)]=wyb[i].first;
    }
}
signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    init();
    dfs(1,0);
    work();
    for(int i=1;i<n;i++){
        cout<<anser[i]<<'\n';
    }
    return 0;
}

Q2

给定一个序列，多次询问一段区间 \([l,r]\)，求区间中相同的数的最远间隔距离。

序列中两个元素的间隔距离指的是两个元素下标差的绝对值。

A2

考虑把区间中每种元素按出现顺序用链表存下来，更新的时候就查询链头链尾元素下表与链头链尾插入删除。

不难看出这些都是 \(O(1)\) 的，最困难的点还是 最远距离。

因此考虑把每种元素的贡献都用值域分块记录下来，查询再在块上查询即可。

#include<bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
	char c=getchar();bool f=0;x=0;
	while(!isdigit(c)) f|=c=='-',c=getchar();
	while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
	if(f) x=-x;return x;
}
template<class t> inline void write(t x){
	if(x<0) putchar('-'),write(-x);
	else{if(x>9) write(x/10);putchar('0'+x%10);}
}
const int maxn = 2e5+114;
const int maxsq = 664;
const int B = 500;
int anser[maxn];
int a[maxn];
map<int,int> lsh;
int n,m,sq;
int tot;
queue<int> recycle;
int t;
struct List_Node{
	int val,Last,Next;
}List[maxn*3];
inline int clone(){
	int New;
	if(recycle.size()>0){
		New=recycle.front();
		recycle.pop();
	}
	else{
		New=++t;
	}
	List[New].val=List[New].Next=List[New].Last=0;
	return New;
}
class Deque{
	private:
		int Begin,End,sz;
	public:
		inline void push_front(int x);
		inline void push_back(int x);
		inline void pop_front();
		inline void pop_back();
		inline int front();
		inline int back();
};
inline void Deque::push_back(int x){
	if(sz==0){
		sz++;
		Begin=End=clone();
		List[Begin].val=x;
	}
	else{
		sz++;
		int New=clone();
		List[New].val=x;
		List[End].Next=New;
		List[New].Last=End;
		End=New;
	}
}
inline void Deque::push_front(int x){
	if(sz==0){
		sz++;
		Begin=End=clone();
		List[Begin].val=x;
	}
	else{
		sz++;
		int New=clone();
		List[New].val=x;
		List[Begin].Last=New;
		List[New].Next=Begin;
		Begin=New;
	}
}
inline void Deque::pop_back(){
	if(sz==1){
		sz--;
		Begin=End=0;
	}
	else{
		sz--;
		recycle.push(End);
		End=List[End].Last;
	}
}
inline void Deque::pop_front(){
	if(sz==1){
		sz--;
		Begin=End=0;
	}
	else{
		sz--;
		recycle.push(Begin);
		Begin=List[Begin].Next;
	}
}
inline int Deque::front(){
	return List[Begin].val;
}
inline int Deque::back(){
	return List[End].val;
}
Deque wyb[maxn];
int cnt[maxn];
inline int pmap(int x){
    return x/B;
}
inline int Lmap(int x){
    return x*B;
}
inline int Rmap(int x){
    return (x+1)*B-1;
}
class Node{
    private:
        int bl_cnt[maxsq];
        int cnt[maxn];
    public:
        inline void add(int x);
        inline void del(int x);
        inline int query();
}chifan;
inline void Node::add(int x){
	if(x==0) return ;
    int bl=pmap(x);
    cnt[x]++;
    bl_cnt[bl]++;
}
inline void Node::del(int x){
	if(x==0) return ;
    int bl=pmap(x);
    cnt[x]--;
    bl_cnt[bl]--;
}
inline int Node::query(){
    for(int i=B+3;i>=0;i--){
        if(bl_cnt[i]>0){
            int L=Lmap(i),R=Rmap(i);
            for(int j=R;j>=L;j--){
                if(cnt[j]>0) return j;
            }
        }
    }
    return 0;
}
struct Query{
    int l,r,id;//存储询问：左右端点以及编号 
}q[maxn];
inline bool cmp(Query a, Query b){
    if(a.l/sq==b.l/sq){
    	if((a.l/sq)%2==1) return a.r<b.r;
    	else return a.r>b.r;
	}
	else return a.l<b.l;
}
inline int value(int x){//颜色 x 的贡献 
	if(cnt[x]==0) return 0;
	if(wyb[x].back()!=wyb[x].front())
		return wyb[x].back()-wyb[x].front();
	else
		return 0;
}
signed main(){
	read(n);
	sq=sqrt(n);
	for(int i=1;i<=n;i++){
		int x;
		read(x);
		if(lsh[x]==0) lsh[x]=++tot;
		a[i]=lsh[x];
	}
	read(m);
	for(int i=1;i<=m;i++){
		read(q[i].l);
		read(q[i].r);
		q[i].id=i;
	}
	sort(q+1,q+m+1,cmp);
	int l=1,r=0;
	for(int i=1;i<=m;i++){
		while(r<q[i].r){
			r++;
			chifan.del(value(a[r]));
			wyb[a[r]].push_back(r);
			chifan.add(value(a[r]));
			cnt[a[r]]++;
		}
		while(l>q[i].l){
			l--;
			chifan.del(value(a[l]));
			wyb[a[l]].push_front(l);
			chifan.add(value(a[l]));
			cnt[a[l]]++;
		}
		while(r>q[i].r){
			chifan.del(value(a[r]));
			wyb[a[r]].pop_back();
			chifan.add(value(a[r]));
			cnt[a[r]]--;
			r--;
		}
		while(l<q[i].l){
			chifan.del(value(a[l]));
			wyb[a[l]].pop_front();
			chifan.add(value(a[l]));
			cnt[a[l]]--;
			l++;
		}
		anser[q[i].id]=chifan.query();
	}
	for(int i=1;i<=m;i++){
		write(anser[i]);
		putchar('\n');
	}	
}

Q3

日记中记录了连续 \(N\) 天发生的事件，大约每天发生一件。

事件有种类之分。第 \(i\) 天发生的事件的种类用一个整数 \(X_i\)
表示，\(X_i\) 越大，事件的规模就越大。

JOI 教授决定用如下的方法分析这些日记：

• 选择日记中连续的几天 \([L,R]\) 作为分析的时间段；

• 定义事件 \(A\) 的重要度 \(W_A\) 为 \(A\times T_A\)，其中 \(T_A\) 为该事件在区间 \([L,R]\) 中出现的次数。

现在，您需要帮助教授求出所有事件中重要度最大的事件是哪个，并输出其重要度。

注意：教授有多组询问。

A3

不难发现还是可以跟上面一样的套路来弄，唯一的问题是贡献太大了，桶存不下。

但是对于每一种数，它的贡献都只有 \(cnt_x\) 种。因此所有贡献一共有 \(\sum_{x} cnt_x = n\) 种，因此考虑把所有贡献离散化，在用哈希表记录映射。

#include<bits/stdc++.h>
#include<bits/extc++.h>
#define int long long
using namespace std;
template<class t> inline t read(t &x){
	char c=getchar();bool f=0;x=0;
	while(!isdigit(c)) f|=c=='-',c=getchar();
	while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
	if(f) x=-x;return x;
}
template<class t> inline void write(t x){
	if(x<0) putchar('-'),write(-x);
	else{if(x>9) write(x/10);putchar('0'+x%10);}
}
const int maxn = 2e5+114;
const int maxsq = 664;
const int B = 340;
int anser[maxn];
int a[maxn],hhx[maxn];
map<int,int> lsh;
__gnu_pbds::gp_hash_table<int,int> wqx;
map<int,int> zyb;
int n,m,sq;
int tot,t;
int cnt[maxn];
inline int pmap(int x){
    return x/B;
}
inline int Lmap(int x){
    return x*B;
}
inline int Rmap(int x){
    return (x+1)*B-1;
}
class Node{
    private:
        int bl_cnt[maxsq];
        int cnt[maxn];
    public:
        inline void add(int x);
        inline void del(int x);
        inline int query();
}chifan;
inline void Node::add(int x){
	if(x==0) return ;
    int bl=pmap(x);
    cnt[x]++;
    bl_cnt[bl]++;
}
inline void Node::del(int x){
	if(x==0) return ;
    int bl=pmap(x);
    cnt[x]--;
    bl_cnt[bl]--;
}
inline int Node::query(){
    for(int i=B+3;i>=0;i--){
        if(bl_cnt[i]>0){
            int L=Lmap(i),R=Rmap(i);
            for(int j=R;j>=L;j--){
                if(cnt[j]>0) return j;
            }
        }
    }
    return 0;
}
struct Query{
    int l,r,id;//存储询问：左右端点以及编号 
}q[maxn];
inline bool cmp(Query a, Query b){
    if(a.l/sq==b.l/sq){
    	if((a.l/sq)%2==1) return a.r<b.r;
    	else return a.r>b.r;
	}
	else return a.l<b.l;
}
inline int value(int x,int xzy){//颜色 x 的贡献
	return wqx[cnt[x]*xzy];
}
int Cnt[maxn];
void init(){
	vector<int> zbz;
	for(int i=1;i<=n;i++){
		Cnt[a[i]]++;
		zbz.push_back(Cnt[a[i]]*hhx[i]); 
	}
	zbz.push_back(0);
	sort(zbz.begin(),zbz.end());
	for(int v:zbz){
		if(wqx[v]==0){
			wqx[v]=t,zyb[t]=v;
			t++;
		}
		//cout<<v<<' '<<wqx[v]<<'\n';
	}
} 
signed main(){
	read(n);
	read(m);
	sq=sqrt(n);
	for(int i=1;i<=n;i++){
		int x;
		read(x);
		if(lsh[x]==0) lsh[x]=++tot;
		a[i]=lsh[x];
		hhx[i]=x;
	}
	init();
	for(int i=1;i<=m;i++){
		read(q[i].l);
		read(q[i].r);
		q[i].id=i;
	}
	sort(q+1,q+m+1,cmp);
	int l=1,r=0;
	for(int i=1;i<=m;i++){
		while(r<q[i].r){
			r++;
			chifan.del(value(a[r],hhx[r]));
			cnt[a[r]]++;
			chifan.add(value(a[r],hhx[r]));
		}
		while(l>q[i].l){
			l--;
			chifan.del(value(a[l],hhx[l]));
			cnt[a[l]]++;
			chifan.add(value(a[l],hhx[l]));
		}
		while(r>q[i].r){
			chifan.del(value(a[r],hhx[r]));
			cnt[a[r]]--;
			chifan.add(value(a[r],hhx[r]));
			r--;
		}
		while(l<q[i].l){
			chifan.del(value(a[l],hhx[l]));
			cnt[a[l]]--;
			chifan.add(value(a[l],hhx[l]));
			l++;
		}
		anser[q[i].id]=chifan.query();
	}
	for(int i=1;i<=m;i++){
		write(zyb[anser[i]]);
		putchar('\n');
	}	
}