其他分享
首页 > 其他分享> > 线段树之合并与分裂

线段树之合并与分裂

作者：互联网

请你维护一些可重集，初始只有一个编号为 \(1\) 的可重集 \(a\)，要支持以下操作：

  1. 0 p x y：将可重集 \(p\) 中大于等于 \(x\) 且小于等于 \(y\) 的所有元素移动到一个新的可重集中。（其编号从 \(2\) 开始，是上次新建的可重集的编号 \(+1\)。）

  2. 1 p t：将可重集 \(t\) 中的元素全部移动到可重集 \(p\) 中，并清空可重集 \(t\)。（之后的操作中不会出现可重集 \(t\)。）

  3. 2 p x q：在可重集 \(p\) 中加入 \(x\) 个数 \(q\)。

  4. 3 p x y：询问可重集 \(p\) 中大于等于 \(x\) 且小于等于 \(y\) 的元素的个数。

  5. 4 p k：询问可重集 \(p\) 中第 \(k\) 小的元素，不存在则输出 -1。

考虑用动态开点的权值树维护每个可重集，操作 2，3，4 是容易维护的。

接下来重点看一下 0，1 操作。

1 操作可以用一个线段树合并的方式解决。

一次合并操作会合并两个权值树，产生的权值树可以看作是两个原树对应位置相加而来的。

由于这些权值树维护的值域都是相同的，我们可以用两个指针同时遍历两颗权值树，相加对应节点的值。

设两个指针为 \(p,q\)，要将 \(q\) 遍历的权值树合并到 \(p\) 遍历的权值树上。注意到动态开点的权值树有很多空节点，这时就需要分情况来讨论：

  1. 若 \(p,q\) 皆非空，在 \(p\) 处加上 \(q\) 处的值，删除 \(q\) 处节点，继续向下递归。

  2. 若 \(p\) 空，\(q\) 非空，则直接将以 \(q\) 为根的这颗子树接到 \(p\) 处，并返回。

  3. 若 \(p\) 非空，\(q\) 空，则直接返回。

  4. 若 \(p,q\) 皆空，直接返回。

代码就是这个样子的：

void merge( int & p , int & q , int l , int r ){
	if( ! p ){ p = q; return; }
	if( ! q ) return;
	if( l == r ){ val( p ) += val( q ) , delet( q ); return; }
	int mid = l + r >> 1;
	merge( ls( p ) , ls( q ) , l , mid );
	merge( rs( p ) , rs( q ) , mid + 1 , r );
	delet( q ) , push_up( p );
}

接下来考虑一下这个操作的复杂度。

注意到，若继续向下递归，必然会删除一个节点，于是总递归的次数不会超过总点数。注意这里的总递归次数值得并非一次操作，而是所有的合并操作。

而一次修改操作会新建 \(O(\log n)\) 个节点，\(m\) 次操作，总点数就是 \(O(m\log n)\) 的，所以所有合并操作的总复杂度就是 \(O(m\log n)\) 的。它的复杂度是均摊的。

分裂操作是提取出一颗权值树上的值域区间 \([x,y]\)，对其新建一棵树，于是我们可以和区间操作一样，在原树上定位到对应的 \(\log\) 个区间，并将经过的节点提取出来构成一颗新树，并顺便在原树中将这个值域中的元素减掉。

其实还可以像 fhq-Treap 那个样子按排名分裂，不过上面这个方法更加简单，效率也高一些。

代码的实现：

void split( int & p , int & q , int l , int r , int L , int R ){
	if( ! p ) return;
	if( L <= l && r <= R ){ q = p , p = 0; return; }
	if( ! q ) q = newv();
	int mid = l + r >> 1;
	if( L <= mid ) split( ls( p ) , ls( q ) , l , mid , L , R );
	if( R > mid ) split( rs( p ) , rs( q ) , mid + 1 , r , L , R );
	push_up( p ) , push_up( q );
}

容易发现这个操作的复杂度和平凡的区间操作是一样的，为单次 \(O(\log n)\)。

其余三个操作的复杂度都是单次 \(O(\log n)\)。

总时间复杂度 \(O(m\log n)\)。

Code：

# include <cstdio>
# include <iostream>

namespace IO{
	inline int read(){
		int ret = 0 , ti = 1;
		char u = getchar();
		while( ! isdigit( u ) ){ if( u == '-' ) ti = -1; u = getchar(); }
		while( isdigit( u ) ) ret = ret * 10 + u - '0' , u = getchar();
		return ret * ti;
	}
}

using namespace std;

typedef long long ll;

const int N = 2e5 + 225;

int n , m;
int a[ N ];
int root[ N ] , nod , cnt;
int recy[ N << 2 ] , tp;

struct Node{ ll v; int lc , rc; }t[ N << 5 ];
# define ls( u ) t[ u ] . lc
# define rs( u ) t[ u ] . rc
# define val( u ) t[ u ] . v

inline int newv(){ return tp ? recy[ tp -- ] : ++ nod; }

inline void delet( int & u ){ ls( u ) = rs( u ) = val( u ) = 0 , recy[ ++ tp ] = u , u = 0; } 

inline void push_up( int u ){ val( u ) = val( ls( u ) ) + val( rs( u ) ); }

int build( int & u , int l , int r ){
	u = newv();
	if( l == r ){ val( u ) = a[ l ]; return u; }
	int mid = l + r >> 1;
	build( ls( u ) , l , mid );
	build( rs( u ) , mid + 1 , r );
	push_up( u );
	return u;
}

void split( int & p , int & q , int l , int r , int L , int R ){
	if( ! p ) return;
	if( L <= l && r <= R ){ q = p , p = 0; return; }
	if( ! q ) q = newv();
	int mid = l + r >> 1;
	if( L <= mid ) split( ls( p ) , ls( q ) , l , mid , L , R );
	if( R > mid ) split( rs( p ) , rs( q ) , mid + 1 , r , L , R );
	push_up( p ) , push_up( q );
}

void merge( int & p , int & q , int l , int r ){
	if( ! p ){ p = q; return; }
	if( ! q ) return;
	if( l == r ){ val( p ) += val( q ) , delet( q ); return; }
	int mid = l + r >> 1;
	merge( ls( p ) , ls( q ) , l , mid );
	merge( rs( p ) , rs( q ) , mid + 1 , r );
	delet( q ) , push_up( p );
}

void modify( int & u , int l , int r , int p , int x ){
	if( ! u ) u = newv();
	if( l == r ){ val( u ) += x; return; }
	int mid = l + r >> 1;
	if( p <= mid ) modify( ls( u ) , l , mid , p , x );
	else modify( rs( u ) , mid + 1 , r , p , x );
	push_up( u );
}

ll query1( int u , int l , int r , int L , int R ){
	if( ! u ) return 0;
	if( L <= l && r <= R ) return val( u );
	int mid = l + r >> 1;
	ll ret = 0;
	if( L <= mid ) ret += query1( ls( u ) , l , mid , L , R );
	if( R > mid ) ret += query1( rs( u ) , mid + 1 , r , L , R );
	return ret;
}

int kth( int u , int l , int r , int k ){
	if( l == r ) return l;
	int mid = l + r >> 1;
	if( val( ls( u ) ) >= k ) return kth( ls( u ) , l , mid , k );
	else return kth( rs( u ) , mid + 1 , r , k - val( ls( u ) ) );
}

void solve(){
	for( int i = 1 ; i <= m ; i ++ ){
		int op = IO :: read() , p = IO :: read();
		if( ! op ){
			int l = IO :: read() , r = IO :: read();
			split( root[ p ] , root[ ++ cnt ] , 1 , n , l , r );
		}
		else if( op == 1 ){
			int q = IO :: read();
			merge( root[ p ] , root[ q ] , 1 , n );
		}
		else if( op == 2 ){
			int c = IO :: read() , x = IO :: read();
			modify( root[ p ] , 1 , n , x , c );
		}
		else if( op == 3 ){
			int l = IO :: read() , r = IO :: read();
			printf( "%lld\n" , query1( root[ p ] , 1 , n , l , r ) );
		}
		else{
			int k = IO :: read();
			if( val( root[ p ] ) < k ) printf( "-1\n" );
			else printf( "%d\n" , kth( root[ p ] , 1 , n , k ) );
		}
	}
}

void input(){
	n = IO :: read() , m = IO :: read();
	for( int i = 1 ; i <= n ; i ++ ) a[ i ] = IO :: read();
}

int main(){
	input();
	build( root[ cnt = 1 ] , 1 , n );
	solve();
	system( "pause" );
	return 0;
}

标签：重集,return,rs,int,线段,合并,mid,分裂,权值
来源： https://www.cnblogs.com/yukari1735/p/15911886.html