CF896E Welcome home,Chtholly/[Ynoi2018]五彩斑斓的世界（并查集+第二分块）

description

五彩斑斓的世界

CF896E Welcome home,Chtholly

五彩斑斓的世界是加强版，所以下面的题解部分是写的加强版

solution

第二分块

查询操作中把$>x$的数全都减去$x$，可以看作把$\le x$的数全都加上$x$，然后来个整体减的懒标记记录

设序列的最大值为$Max$

• 若$2x\ge Max$

  则令$>x$的数减去$x$，就没有比$x$大的数了，则$Max$在操作后至少减少$Max-x$

• 若$2x<Max$

  则令$\le x$的数加上$x$，就没有比$x$小的数了，然后打全局减的标记，则$Max$在操作后至少减少$x$

不管怎么操作，这个$Max$都是单调递减的，且初始的最大值也只有$5\times 10^5$

（下面假设$n,m$，值域同阶）

全局修改，根据上面的规则，只需要枚举需要被修改的那些数值即可

为了不$\text{TLE}$，我们肯定希望能做到$O(1)$的修改每一个值

这里考虑使用并查集

• 把相同的值并在一起。修改的话，就直接操作未修改前的值所在并查集的根，然后直接操作根连接到新值所在并查集的根，同时记录每个数的出现次数，转移时一起加过去即可。这里是需要连个边完成并查集合并，并不需要路径压缩，所以是$O(1)$的。查询也是$O(1)$的。

如果要查询位置的具体值，就需要用并查集的找父亲部分了。用路径压缩的并查集来找，时间复杂度是$O(\alpha n)$的

到这里，自然而然（？？？）就是对序列进行分块操作了

• 一个整块的修改和查询，直接按照上面的方法操作，所有块合在一起的时间复杂度是$O(n\sqrt{n})$
• 一个散块的修改，考虑直接暴力还原实际值，然后重构，单次复杂度是$O(\sqrt{n})$
• 一个散块的查询，同样考虑直接暴力问每个位置的实际值，单次复杂度$O(\sqrt{n})$

所以整体的复杂度就是$O(n\sqrt{n})$，时间是$12s$，只要不是太丑肯定是随便跑的

但是发现这道题不卡时间卡空间，只有$64MB$

如果把每个块开出来，然后边操作边询问，就会发现一开那么多个块就会直接$\text{MLE}$

但是，好在天无绝人之路，题必有正解之法

发现，这并不是强制在线，嗯有点意思，欸每个块好像泾渭分明，互相独立

所以！我们将询问离线下来，枚举每个块，每一次处理枚举块对所有询问的影响

（相当于是调换了内外层循环）

code

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define maxn 1000005
#define maxv 100005 
#define maxB 1005
struct query { int opt, l, r, x; }q[maxn];
int n, m, len, block, Max, tag;
int a[maxn], siz[maxv], f[maxv], pre[maxn], val[maxn], ans[maxn];
//pre不需要路径压缩的并查集
//f需要路径压缩的并查集 
void build( int l, int r ) {
	Max = tag = 0;
	for( int i = l;i <= r;i ++ ) {
		Max = max( Max, a[i] );
		if( ! f[a[i]] ) {
			val[i] = a[i];
			f[a[i]] = i;
			pre[i] = i;
		}
		else
			pre[i] = f[a[i]];
		siz[a[i]] ++;
	}
}

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

void modify( int x, int t ) {
	if( f[t] ) pre[f[x]] = f[t];
	else val[f[t] = f[x]] = t;
	siz[t] += siz[x];
	f[x] = siz[x] = 0;
}

void modify_whole_block( int x ) {
	if( x > ( Max - tag ) / 2 ) {
		for( int i = x + 1 + tag;i <= Max;i ++ )
			if( f[i] ) modify( i, i - x );
		Max = min( Max, x + tag );
	}
	else {
		for( int i = tag;i <= x + tag;i ++ )
			if( f[i] ) modify( i, i + x );
		tag += x;
	}
}

//散块直接暴力重构 
void modify_apart_block( int l, int r, int ql, int qr, int x ) {
	ql = max( ql, l ), qr = min( r, qr );
	for( int i = l;i <= r;i ++ ) {
		int t = val[find( i )];
		a[i] = t - tag;
		f[t] = siz[t] = 0;
	}
	for( int i = l;i <= r;i ++ ) val[i] = 0;
	for( int i = ql;i <= qr;i ++ ) if( a[i] > x ) a[i] -= x;
	build( l, r );
}

int query( int l, int r, int ql, int qr, int x ) {
	int cnt = 0;
	ql = max( ql, l ), qr = min( qr, r );
	for( int i = ql;i <= qr;i ++ ) if( val[find( i )] - tag == x ) cnt ++;
	return cnt;
}

int main() {
	scanf( "%d", &n );
	block = sqrt( n );
	len = ( n - 1 ) / block + 1;
	for( int i = 1;i <= n;i ++ ) scanf( "%d", &a[i] );
	scanf( "%d", &m );
	for( int i = 1;i <= m;i ++ ) 
		scanf( "%d %d %d %d", &q[i].opt, &q[i].l, &q[i].r, &q[i].x );
	for( int i = 1;i <= len;i ++ ) {
		int l = ( i - 1 ) * block + 1;
		int r = min( i * block, n );
		build( l, r );
		for( int j = 1, op, ql, qr, x;j <= m;j ++ ) {
			op = q[j].opt, ql = q[j].l, qr = q[j].r, x = q[j].x;
			if( qr < l or r < ql ) continue;
			if( op & 1 ) {
				if( ql <= l and r <= qr ) modify_whole_block( x );
				else modify_apart_block( l, r, ql, qr, x );
			}
			else {
				if( x + tag > 1e5 + 1 ) continue;
				if( ql <= l and r <= qr ) ans[j] += siz[x + tag];
				else ans[j] += query( l, r, ql, qr, x );
			}
		}
		memset( f, 0, sizeof( f ) );
		memset( siz, 0, sizeof( siz ) );
	}
	for( int i = 1;i <= m;i ++ ) if( q[i].opt == 2 ) printf( "%d\n", ans[i] );
	return 0;
}