CF1491H Yuezheng Ling and Dynamic Tree（分块）

description

题目链接

solution

非常清新的小分块题了

前提：将序列分成$\sqrt{n}$块，每块有$\sqrt{n}$个数，记第$i$个块的左右边界为$L_i,R_i$，记第$i$个数所在块为$bloc{k}_i$

定义$to{p}_i$：节点$i$的祖先中，与$i$不在同一个块的最大编号点

【这个真的很妙，可以说是这道题的解法考察点了】

问题是如何在$a_{l,r}$更新时，对某个块$x$内的被覆盖节点$i\in [l,r]$的$to{p}_i$进行更新？？

• 如果更新后的$a_i<L_x$，则$a_i$成为新的满足$top$定义的最大编号点【$i$的祖先都已经全变成了$a_i$的祖先，再加个$a_i$本身】，$to{p}_i=a_i$
• 如果更新后的$a_i$仍然属于块$x$内，则直接链接过去，$to{p}_i=to{p}_{a_i}$

明白了如何维护块内信息，接下来就是对不同块进行操作了

首先考虑修改操作

• 散块（只覆盖了块内部分点）：直接暴力修改点的$a_i$值，然后暴力重构，单次操作时间复杂度$O(\sqrt{n})$

• 整块：懒标记$ta{g}_i$表示点$i$的$a_i$还没减多少【比真实的$a_i$多了$ta{g}_i$，未真实操作修改】，但这个时候块内某些点的$to{p}_i$可能已经发生了变化，没有实时更新就会影响后面的查询操作，而每次暴力修改又需要整个块的遍历，多个整块几乎就是$O($修改区间长度$)$的，无法保证时间复杂度

  实际上，发现对于每个块，经过$\sqrt{n}$次整块修改操作后，$a_i$都至少会变为$a_i-\sqrt{n}$，一定在当前块前面的块

  因此，我们可以维护每个块被修改的次数$cn{t}_x$当$cn{t}_x>\sqrt{n}$，就不再暴力修改整块，而是直接整块的区间减法，这个时候的$a_i$一定是其的$to{p}_i$，否则就暴力修改

  每个块最多修改$\sqrt{n}$次，每次需要$O(\sqrt{n})$遍历修改，一共有$\sqrt{n}$个块，总时间复杂度是$O(n\sqrt{n})$的

接着考虑询问操作

找$\text{lca}$肯定是倍增暴力啦！这里直接使用暴力爬山法

考虑询问$u,v$两个点的$lca$

• 若$bloc{k}_u\ne bloc{k}_v$，则选择对应$block$编号较大的点，跳到其$top$点

• 若$bloc{k}_u=bloc{k}_v$且$to{p}_u\ne to{p}_v$，则两个节点一起跳对应的$top$点

• 若$bloc{k}_u=bloc{k}_v$且$to{p}_u=to{p}_v$，则一直让节点编号大的点跳父亲$a$，直到两点相同为止

  【注意在跳的时候，一定要减去所在块的$ta{g}_x$标记，才能得到真正的$top/a$】

一个点跳$top$的次数最多为$\frac{n}{\sqrt{n}}=\sqrt{n}$次，跳完$top$就是在一个块里面的跳$a$，最多也是$\sqrt{n}$次，所以单次询问时间复杂度为$O(\sqrt{n})$

本题最终的时间复杂度为$O((n+q)\sqrt{n})$

code

#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 100005
#define maxB 320
int n, Q, B, B_cnt;
int a[maxn], block[maxn], L[maxB], R[maxB], cnt[maxB], top[maxn], tag[maxB];

void pushup( int x ) {
	for( int i = L[x];i <= R[x];i ++ ) a[i] = max( 1, a[i] - tag[x] );
	tag[x] = 0;
	for( int i = L[x];i <= R[x];i ++ ) {
		if( a[i] < L[x] ) top[i] = a[i];
		else top[i] = top[a[i]];
	}
}

void modify( int l, int r, int x ) {
	if( block[l] == block[r] ) {
		for( int i = l;i <= r;i ++ ) a[i] = max( 1, a[i] - x );
		pushup( block[l] );
	}
	else {
		for( int i = l;i <= R[block[l]];i ++ ) a[i] = max( 1, a[i] - x ); pushup( block[l] );
		for( int i = L[block[r]];i <= r;i ++ ) a[i] = max( 1, a[i] - x ); pushup( block[r] );
		for( int i = block[l] + 1;i < block[r];i ++ ) {
			cnt[i] ++, tag[i] = min( n, tag[i] + x );
			if( cnt[i] <= B ) pushup( i );
		}
	}
}

int query_top( int i ) { return max( 1, top[i] - tag[block[i]] ); }

int query_a( int i ) { return max( 1, a[i] - tag[block[i]] ); }

int lca( int x, int y ) {
	while( 1 ) {
		if( block[x] < block[y] ) swap( x, y );
		if( block[x] ^ block[y] ) x = query_top( x );
		else {
			if( top[x] ^ top[y] ) x = query_top( x ), y = query_top( y );
			else break;
		}
	}
	while( x ^ y ) {
		if( x < y ) swap( x, y );
		x = query_a( x );
	}
	return x;
}

int main() {
	scanf( "%d %d", &n, &Q );
	B = sqrt( n ), B_cnt = ( n - 1 ) / B + 1;
	for( int i = 2;i <= n;i ++ ) {
		scanf( "%d", &a[i] );
		block[i] = ( i - 1 ) / B + 1;
	}
	for( int i = 1;i <= block[n];i ++ ) 
		L[i] = ( i - 1 ) * B + 1, R[i] = min( n, i * B ), pushup( i );
	for( int i = 1, opt, l, r, x;i <= Q;i ++ ) {
		scanf( "%d %d %d", &opt, &l, &r );
		if( opt & 1 ) scanf( "%d", &x ), modify( l, r, x );
		else printf( "%d\n", lca( l, r ) );
	}
	return 0;
}