「Note」您想来点数据结构吗？

大分块系列

最初分块 \(\color{black}{P4119}\)

考虑数列分块+值域分块

数列分块需要维护：

\(nid_{i,j}\)	\(fid_i\)	\(f_i\)
块 \(i\) 中数字 \(j\) 的并查集的根	以 \(i\) 为根的并查集表示的数字	并查集

值域分块需要维护：

\(ncnt_{i,j}\)	\(bcnt_{i,j}\)
前 \(i\) 个块数字 \(j\) 的出现次数	前 \(i\) 个块中在值域块 \(j\) 中的个数

预处理：

序列分块、值域分块块长，序列、值域每个值对应块。

每个块用 \(nid,fid\) 建立映射，\(f_i\) 连向此块与当前点值相同的第一个值（的下标），若此块中第一次出现当前点值，则考虑对 \(nid,fid\) 赋值。

显著地，扫一遍序列同时现将 \(ncnt,bcnt\) 赋上初值，再进行一遍前缀和。

修改：

碎块直接暴力赋值暴力重构，记得更新前缀和。

整块直接合并 \(x,y\) 两值，若 \(y\) 值不存在则直接将 \(x\) 并查集根节点所代表值改为 \(y\)。

整块的前缀和合并更新，扫整块的时候记录一个 \(temp\) 用来一次性更新前缀和，保证复杂度。

查询：

碎块处理需要先访问到序列真实值。

考虑开两个数组维护碎块的每个值出现次数、值域块内值个数。

查询直接先一点点跳整块（要算上碎块维护的值以及整块的值），然后一个个跳数字找到答案。

查询完毕记得清空维护碎块数组，注意要用添加的镜像操作回退，保证复杂度。

整体思路比较清晰，维护时注意细节，考虑每一个变量是否会在操作是变化，再卡卡常即可。

$\text{Code}$：

#include<bits/stdc++.h>
#define LL long long
#define UN unsigned
using namespace std;
//--------------------//
//IO
int rd()
{
	int ret=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();}
	while(ch>='0'&&ch<='9')ret=ret*10+ch-'0',ch=getchar();
	return ret*f;
}
//--------------------//
const int N=1e5+5,QN=400,QN2=500;

int n,m;
//--------------------//
struct Dec
{
	struct Block
	{
		int l,r;
		int nid[N];
	}b[QN];
	int ncnt[QN][N],bcnt[QN][QN2];

	int fid[N],f[N];
	int len1,bcnt1,bl1[N];
	int len2,bcnt2,bl2[N];
	int s[N];

	inline int find(int x){return f[x]==x?x:f[x]=find(f[x]);}

	inline void init()
	{
		len1=512;
		len2=256;
		for(register int i=1;i<=1e5;i++)
			bl2[i]=((bl2[i-1]*len2+1)==i?++bcnt2:bcnt2);
        int maxt=0;
		for(register int i=1;i<=n;i++)
		{
			bl1[i]=((bl1[i-1]*len1+1)==i?++bcnt1:bcnt1);
			if(!b[bl1[i]].nid[s[i]])
			{
				b[bl1[i]].nid[s[i]]=i;
				fid[i]=s[i];
			}
			f[i]=b[bl1[i]].nid[s[i]];
			ncnt[bl1[i]][s[i]]++;
			bcnt[bl1[i]][bl2[s[i]]]++;
		}
		for(register int i=1;i<=bcnt1;i++)
		{
			b[i].l=(i-1)*len1+1,b[i].r=min(n,i*len1);
			for(register int j=1;j<=1e5;j++)
				ncnt[i][j]+=ncnt[i-1][j];
			for(register int j=1;j<=bcnt2;j++)
				bcnt[i][j]+=bcnt[i-1][j];
		}
		return;
	}
	inline void cha_pic(int id,int l,int r,int x,int y)
	{
		int xcnt=0;
		//printf("\npic:\n");
		for(register int i=b[id].l;i<=b[id].r;i++)
			s[i]=fid[find(f[i])];
        for(register int i=l;i<=r;i++)
        {
			if(s[i]==x)
			{
				xcnt++;
				s[i]=y;
			}
        }
		for(register int i=b[id].l;i<=b[id].r;i++)
		{
			if(f[i]==i)
			{
				b[id].nid[fid[i]]=0;
				fid[i]=0;
			}
			f[i]=0;
		}
		for(register int i=b[id].l;i<=b[id].r;i++)
		{
			if(!b[id].nid[s[i]])
			{
				b[id].nid[s[i]]=i;
				fid[i]=s[i];
			}
			f[i]=b[id].nid[s[i]];
		}
		for(register int i=id;i<=bcnt1;i++)
		{
			ncnt[i][x]-=xcnt,ncnt[i][y]+=xcnt;
			bcnt[i][bl2[x]]-=xcnt,bcnt[i][bl2[y]]+=xcnt;
		};
		return;
	}

	inline void change(int l,int r,int x,int y)
	{
		if(x==y)
			return;
		int now1=bl1[l],now2=bl1[r];
        if(!(ncnt[now2][x]-ncnt[now1-1][x]))
            return;
		if(now1==now2)
		{
			cha_pic(now1,l,r,x,y);
			return;
		}
		cha_pic(now1,l,b[now1].r,x,y);
		cha_pic(now2,b[now2].l,r,x,y);
		int tem=0;
		for(register int temp,i=now1+1;i<now2;i++)
		{
			temp=ncnt[i][x]-ncnt[i-1][x];
			ncnt[i-1][x]-=tem,ncnt[i-1][y]+=tem;
			bcnt[i-1][bl2[x]]-=tem,bcnt[i-1][bl2[y]]+=tem;
			tem+=temp;
			if(!b[i].nid[y])
			{
				b[i].nid[y]=b[i].nid[x];
				fid[b[i].nid[y]]=y;
			}
			else
			{
				fid[b[i].nid[x]]=0;
				f[b[i].nid[x]]=b[i].nid[y];
			}
			b[i].nid[x]=0;
		}
		if(now1+1<now2)
		{
            for(register int i=now2-1;i<=bcnt1;i++)
            {
                ncnt[i][x]-=tem,ncnt[i][y]+=tem;
                bcnt[i][bl2[x]]-=tem,bcnt[i][bl2[y]]+=tem;
            }
		}
		return;
	}
	int temnc[N],tembc[QN];
	inline int get_ans(int k,int l,int r)
	{
		int now=1;
		while(k>tembc[now]+bcnt[r][now]-bcnt[l-1][now])
			k-=tembc[now]+bcnt[r][now]-bcnt[l-1][now],now++;
		for(register int i=(now-1)*len2+1;i<=min(now*len2,100000);i++)
		{
			k-=temnc[i]+ncnt[r][i]-ncnt[l-1][i];
			if(k<=0)
				return i;
		}
		return 114514;
	}
	inline int query(int l,int r,int k)
	{
		int now1=bl1[l],now2=bl1[r],res=0;
		if(now1==now2)
		{
			for(register int i=l;i<=r;i++)
				s[i]=fid[find(i)],temnc[s[i]]++,tembc[bl2[s[i]]]++;
			res=get_ans(k,1,0);
			for(register int i=l;i<=r;i++)
				temnc[s[i]]--,tembc[bl2[s[i]]]--;
			return res;
		}
        for(register int i=l;i<=b[now1].r;i++)
            s[i]=fid[find(i)],temnc[s[i]]++,tembc[bl2[s[i]]]++;
        for(register int i=b[now2].l;i<=r;i++)
            s[i]=fid[find(i)],temnc[s[i]]++,tembc[bl2[s[i]]]++;
		res=get_ans(k,now1+1,now2-1);
        for(register int i=l;i<=b[now1].r;i++)
            temnc[s[i]]--,tembc[bl2[s[i]]]--;
        for(register int i=b[now2].l;i<=r;i++)
            temnc[s[i]]--,tembc[bl2[s[i]]]--;
		return res;
	}
}D;
//--------------------//
int main()
{
	n=rd(),m=rd();
	for(int i=1;i<=n;i++)
		D.s[i]=rd();
	D.init();
	for(int op,l,r,x,y,i=1;i<=m;i++)
	{
		op=rd();
		if(op==1)
			l=rd(),r=rd(),x=rd(),y=rd(),D.change(l,r,x,y);
		else
			l=rd(),r=rd(),x=rd(),printf("%d\n",D.query(l,r,x));
	}
    return 0;
}

第二分块 \(\color{black}{P4117}\)

与上一道题类似，考虑用并查集维护信息。

\(fid_i\)	\(sid_i\)	\(cnt_i\)	\(mxv\)
以 \(i\) 为根的并查集代表的数字	数字 \(i\) 的并查集根的编号	数字 \(i\) 出现的次数（包括懒标记）	块内当前最大值

对于整个块一起修改：

当 \(mxv \ge 2x + lazy\) 时，把小于 \(x\) 的向上合并，并打懒标记表示区间需要减多少。

当 \(mxv > 2x + lazy\) 时，把大于 \(x\) 的向下合并。

对于碎块修改直接暴力重构即可。

$\text{Code}$：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
typedef unsigned UN;
typedef double DB;
//--------------------//
inline int rd() {
    int ret = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-')
            f = -f;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        ret = ret * 10 + ch - '0', ch = getchar();
    return ret * f;
}
//--------------------//
const int N = 1e6 + 5, M = 5e5 + 5, V = 5e5 + 5, QN = 1024 + 5;
const int B = 1024;

int n, m, a[N];

struct Que {
    int op, l, r, x;
} q[M];

#define bl(x) (((x) + B - 1) / B)

int len, l, r, mxv, lazy, s[QN], f[QN], fid[QN], sid[V], cnt[V];

inline int find(int x) {return ((x == f[x]) ? x : f[x] = find(f[x]));}

inline void re_mak() {
    mxv = 0;
    for (int i = 1; i <= len; i++) {
        mxv = max(mxv, s[i]), cnt[s[i]]++, fid[i] = s[i];
        if (!sid[s[i]])
            sid[s[i]] = i, f[i] = i;
        else
            f[i] = sid[s[i]];
    }
}

inline void mak_re() {
    for (int i = 1; i <= len; i++) {
        s[i] = fid[find(i)];
        sid[s[i]] = cnt[s[i]] = 0, s[i] -= lazy;
    }
    for (int i = 1; i <= len; i++)
        fid[i] = 0;
    lazy = 0;
}

inline void init(int id) {
    mak_re();
    l = (id - 1) * B + 1, r = min(id * B, n), len = r - l + 1;
    for (int pos = 1, i = l; i <= r; i++, pos++)
        s[pos] = a[i];
    re_mak();
}

inline void merge(int i, int to) {
    cnt[to] += cnt[i], cnt[i] = 0;
    if (!sid[to])
        sid[to] = sid[i], fid[sid[to]] = to;
    else
        f[sid[i]] = sid[to];
    sid[i] = 0;
}

inline void change1(int l, int r, int x) {
    if (mxv < x + lazy || !x)
        return;
    mak_re();
    for (int i = l; i <= r; i++)
        s[i] -= (s[i] > (x + lazy)) * x;
    re_mak();
}

inline void change2(int x) {
    if (!x)
        return;
    if (mxv >= x * 2 + lazy) {
        for (int i = lazy; i <= x + lazy; i++)
            if (sid[i])
                merge(i, i + x);
        lazy += x;
    } else {
        for (int i = lazy + x + 1; i <= mxv; i++)
            if (sid[i])
                merge(i, i - x);
        mxv = min(lazy + x, mxv);
    }
}

inline int query1(int l, int r, int x) {
    if (x + lazy > mxv)
        return 0;
    int res = 0;
    for (int i = l; i <= r; i++)
        res += (fid[find(i)] == x + lazy);
    return res;
}

inline int query2(int x) {
    if (x + lazy <= 5e5)
        return cnt[x + lazy];
    return 0;
}

int acnt, ans[M];
//--------------------//
int main() {
    n = rd(), m = rd();
    for (int i = 1; i <= n; i++)
        a[i] = rd();
    for (int i = 1; i <= m; i++)
        q[i].op = rd(), q[i].l = rd(), q[i].r = rd(), q[i].x = rd();
    int mxb = bl(n);
    for (int i = 1; i <= mxb; i++) {
        init(i), acnt = 0;
        for (int j = 1; j <= m; j++) {
            acnt += (q[j].op == 2);
            if (q[j].op == 1) {
                if (q[j].l <= l && q[j].r >= r)
                    change2(q[j].x);
                else {
                    if (l <= q[j].l && r >= q[j].r)
                        change1(q[j].l - l + 1, q[j].r - l + 1, q[j].x);
                    else if (l <= q[j].l && q[j].l <= r)
                        change1(q[j].l - l + 1, len, q[j].x);
                    else if (l <= q[j].r && r >= q[j].r)
                        change1(1, q[j].r - l + 1, q[j].x);
                }
            } else {
                if (q[j].l <= l && q[j].r >= r)
                    ans[acnt] += query2(q[j].x);
                else {
                    if (l <= q[j].l && r >= q[j].r)
                        ans[acnt] += query1(q[j].l - l + 1, q[j].r - l + 1, q[j].x);
                    else if (l <= q[j].l && q[j].l <= r)
                        ans[acnt] += query1(q[j].l - l + 1, len, q[j].x);
                    else if (l <= q[j].r && r >= q[j].r)
                        ans[acnt] += query1(1, q[j].r - l + 1, q[j].x);
                }
            }
        }
    }
    for (int i = 1; i <= acnt; i++)
        printf("%d\n", ans[i]);
    return 0;
}

第四分块

\(fid_i\)	\(sid_{i, j}\)	\(val_{i, j}\)	\(vid_{i, j}\)	\(dis_{i, j, k}\)	\(lx_{i, j}\)	\(rx_{i, j}\)
以 \(i\) 为根的并查集代表的数字	块 \(i\) 中，数字 \(j\) 的并查集根的编号	块 \(i\) 中，数字 \(j\) 的真实值	块 \(i\) 中，真实值为 \(j\) 的数字的离散值	块 \(i\) 中，离散值为 \(j, k\) 的值的距离	块 \(i\) 中，数字 \(j\) 最左出现位置	块 \(i\) 中，数字 \(j\) 最右出现位置