[bzoj3626][LNOI2014]LCA 树链剖分

3626: [LNOI2014]LCA

Time Limit: 10 Sec   Memory Limit: 128 MB
[ Submit][ Status][ Discuss]

Description

给出一个n个节点的有根树（编号为0到n-1，根节点为0）。一个点的深度定义为这个节点到根的距离+1。
设dep[i]表示点i的深度，LCA(i,j)表示i与j的最近公共祖先。
有q次询问，每次询问给出l r z，求sigma_{l<=i<=r}dep[LCA(i,z)]。
（即，求在[l,r]区间内的每个节点i与z的最近公共祖先的深度之和）

Input

第一行2个整数n q。
接下来n-1行，分别表示点1到点n-1的父节点编号。
接下来q行，每行3个整数l r z。

Output

输出q行，每行表示一个询问的答案。每个答案对201314取模输出

Sample Input

5 2
0
0
1
1
1 4 3
1 4 2

Sample Output

8
5

HINT

共5组数据，n与q的规模分别为10000,20000,30000,40000,50000。

Source

好题（因为我做不来）。

简化一下问题：

假设所有点初始点权为0，求两个数lca的深度可以等价于在一个点到lca的路径都加上1，再求另一个点到根的路径的点权和。

那么求单点到一个点集合S的也行（我们把S中每一个点到根节点路径上点权+1，再求这个点到根的路径的点权和，可以等价于求所有lca的深度的和）

我们移动这个单点再求它到根节点的点权和也是相当于到S中每一个lca的深度和

现在再看这道题，我们求l到r的区间上所有点和这个点的lca深度和是否可以相当于：

1到r的区间上所有点和这个点的lca深度和 - 1到l-1的区间上所有点和这个点的lca深度和

这个时候我们就可以想到这道题的解法了

把每一个询问拆成l-1和r

从小到大排序，每次加入一个节点并把区间末端是这个节点的查询一下，用树链剖分实现

因为有模数然而我答案搞忘模了，考场上卡这个的话就算想到正解（只是假设）也暴零

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <set>
#include <map>
using namespace std;
const int N = 100000 + 5;
const int mod = 201314;
int last[N], cnt, siz[N], bel[N], dep[N], pos[N], fa[N], id;
int n, Q, flag[N<<2], sum[N<<2];
struct Edge{ int to, next; }e[N<<1];
void insert( int u, int v ){
	e[++cnt].to = v; e[cnt].next = last[u]; last[u] = cnt;
	e[++cnt].to = u; e[cnt].next = last[v]; last[v] = cnt;
}
void dfs( int x, int f ){
	siz[x] = 1; fa[x] = f;
	for( int i = last[x]; i; i = e[i].next )
		if( e[i].to ^ f ){
			dep[e[i].to] = dep[x] + 1;
			dfs( e[i].to, x );
			siz[x] += siz[e[i].to];
		}
}
void divi( int x, int chain ){
	int k = 0; bel[x] = chain; pos[x] = ++id;
	for( int i = last[x]; i; i = e[i].next )
		if( dep[e[i].to] == dep[x] + 1 )
			if( siz[e[i].to] > siz[k])
				k = e[i].to;
	if( !k ) return ; divi( k, chain );
	for( int i = last[x]; i; i = e[i].next )
		if( dep[e[i].to] == dep[x] + 1 )
			if( e[i].to ^ k )
				divi( e[i].to, e[i].to );
}
void pushdown( int k, int l, int r ){
	if( flag[k] ){
		int mid = l + r >> 1;
		flag[k<<1] = ( flag[k<<1] + flag[k] ) % mod;
		flag[k<<1|1] = ( flag[k<<1|1] + flag[k] ) % mod;
		sum[k<<1] = ( sum[k<<1] + 1LL * flag[k] * ( mid - l + 1 ) % mod ) % mod;
		sum[k<<1|1] = ( sum[k<<1|1] + 1LL * flag[k] * ( r - mid ) % mod ) % mod;
		flag[k] = 0;
	}
}
void update( int k ){
	sum[k] = ( sum[k<<1] + sum[k<<1|1] ) % mod;
}
void change( int k, int l, int r, int L, int R ){
	if( L <= l && r <= R ){
		flag[k] = ( flag[k] + 1 ) % mod; sum[k] = ( sum[k] + ( r - l + 1 ) ) % mod;
		return ;
	}
	pushdown( k, l, r );
	int mid = l + r >> 1;
	if( L <= mid ) change( k<<1, l, mid, L, R );
	if( R >  mid ) change( k<<1|1, mid + 1, r, L, R );
	update( k );
}
int query( int k, int l, int r, int L, int R ){
	if( L <= l && r <= R ) return sum[k];
	pushdown( k, l, r );
	int mid = l + r >> 1, res = 0;
	if( L <= mid ) res = ( res + query( k<<1, l, mid, L, R ) ) % mod;
	if( R >  mid ) res = ( res + query( k<<1|1, mid + 1, r, L, R ) ) % mod;
	update( k );
	return res;
}
struct Query{
	int x, y, id, flag;
	bool operator < ( const Query &a )const{
		return x < a.x;
	}
}d[N<<1];
int tot = 0, ans[N];
void change( int x, int f ){
	while( bel[x] ^ bel[f] ){
		change( 1, 1, n, pos[bel[x]], pos[x] );
		x = fa[bel[x]];
	}
	change( 1, 1, n, pos[f], pos[x] );
}
int query( int x, int f ){
	int res = 0;
	while( bel[x] ^ bel[f] ){
		res = ( res + query( 1, 1, n, pos[bel[x]], pos[x] ) ) % mod;
		x = fa[bel[x]];
	}
	res = ( res + query( 1, 1, n, pos[f], pos[x] ) ) % mod;
	return res;
}
int main(){
	scanf( "%d%d", &n, &Q );
	for( int i = 2, x; i <= n; i++ ) scanf( "%d", &x ), x++, insert( x, i );
	dfs( 1, 0 ); divi( 1, 1 );
	for( int i = 1, l, r, z; i <= Q; i++ ){
		scanf( "%d%d%d", &l, &r, &z ); l++; r++; z++;/* if( l == 1 ) l++; */
		d[++tot].x = l - 1; d[tot].flag = -1; d[tot].id = i; d[tot].y = z;
		d[++tot].x =     r; d[tot].flag =  1; d[tot].id = i; d[tot].y = z;
	}
	sort( d + 1, d + tot + 1 );
	int j = 0;
	for( int i = 1; i <= tot; i++ ){
		while( j < d[i].x ) j++, change( j, 1 );
		ans[d[i].id] += d[i].flag * query( d[i].y, 1 );
	}
	for( int i = 1; i <= Q; i++ ) printf( "%d\n", ( ans[i] + mod ) % mod );
	return 0;
}
/*
5 2
0
0
1
1
1 4 3
1 4 2
*/