一二三系列之CodeChef分块——Chef and Churu，Chef and Problems，Children Trips

Chef and Churu

source

solution

对于单独的$i$，查询可以用线段树/树状数组$O(n\log n)$，这暗示可以平衡查询修改次数

分块

预处理$cn{t}_{i,j}:$ $A_j$对第$i$块包含的函数贡献次数

每次修改的时候，相当于$+val-A_{pos}$

枚举块，直接整体修改$cnt\times (val-A_{pos})$​

• 如果是$O(\log n)$修改值
• 查询整块直接调用$\sqrt{n}$
• 散块区间查询$\sqrt{n}\log n$
• 最后时间复杂度是$O(Q_1(\sqrt{n}+logn)+Q_2(\sqrt{n}+\sqrt{n}\log n))$
• 卡在查询的$\sqrt{n}\log n$，非常难受

再分块，$O(\sqrt{n})$ 修改，$O(1)$查询

用tag记录整块的整体加标记，w记录散块暴力加

查询的时候，找到$i$​的w值再加上所在块的整体加tag

时间复杂度$O(Q_1(\sqrt{n}+\sqrt{n})+Q_2(\sqrt{n}+\sqrt{n}))=O(Q\sqrt{n})$​

code

#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
#define int unsigned long long
#define maxn 100005
#define maxB 320
int n, Q, B;
int A[maxn], L[maxn], R[maxn], block[maxn], sum[maxB], w[maxn], tag[maxB];
int cnt[maxB][maxn];

void modify( int pos, int val ) {
	for( int i = 1;i <= block[n];i ++ )
		sum[i] += cnt[i][pos] * ( val - A[pos] );
	for( int i = block[pos] + 1;i <= block[n];i ++ )
		tag[i] += val - A[pos];
	for( int i = pos;i <= min( n, B * block[pos] );i ++ )
		w[i] += val - A[pos];
	A[pos] = val;
}

int query( int i ) { return w[i] + tag[block[i]]; }

int query( int l, int r ) {
	int ans = 0;
	if( block[l] == block[r] )
		for( int i = l;i <= r;i ++ )
			ans += query( R[i] ) - query( L[i] - 1 );
	else {
		for( int i = l;i <= B * block[l];i ++ )
			ans += query( R[i] ) - query( L[i] - 1 );
		for( int i = B * ( block[r] - 1 ) + 1;i <= r;i ++ )
			ans += query( R[i] ) - query( L[i] - 1 );
		for( int i = block[l] + 1;i < block[r];i ++ )
			ans += sum[i];
	}
	return ans;
}

signed main() {
	scanf( "%llu", &n );
	B = sqrt( n );
	for( int i = 1;i <= n;i ++ ) {
		scanf( "%llu", &A[i] ), w[i] = A[i];
		block[i] = ( i - 1 ) / B + 1;
	}
	for( int i = 1;i <= n;i ++ )
		scanf( "%llu %llu", &L[i], &R[i] );
	for( int i = 1;i <= n;i ++ )
		w[i] += w[i - 1];
	for( int i = 1;i <= block[n];i ++ ) {
		for( int j = ( i - 1 ) * B + 1;j <= min( n, i * B );j ++ )
			cnt[i][L[j]] ++, cnt[i][R[j] + 1] --;
		for( int j = 1;j <= n;j ++ )
			cnt[i][j] += cnt[i][j - 1];
		for( int j = 1;j <= n;j ++ )
			sum[i] += cnt[i][j] * A[j];
	}
	scanf( "%llu", &Q );
	int opt, x, y;
	while( Q -- ) {
		scanf( "%llu %llu %llu", &opt, &x, &y );
		if( opt & 1 ) modify( x, y );
		else printf( "%llu\n", query( x, y ) );
	}
	return 0;
}

Chef and Problems

source

solution

分块

预处理出整块$i,j$之间的答案

具体而言，用$las{t}_i$记录年龄为$i$的第一个人的出现位置，显然越往后的人与第一个年龄相同的人距离越大

对于查询，包含的整块直接调用预处理的数组

散块部分，就在区间中lower_bound找最远的，把人按年龄分道不同容器vector找坐标

code

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
#define maxn 100005
#define maxB 1005
vector < int > pos[maxn];
int n, m, Q, B;
int A[maxn], block[maxn], last[maxn];
int len[maxB][maxB];

int main() {
	scanf( "%d %d %d", &n, &m, &Q );
	B = 100;
	for( int i = 1;i <= n;i ++ ) {
		scanf( "%d", &A[i] );
		block[i] = ( i - 1 ) / B + 1;
	}
	for( int i = 1;i <= block[n];i ++ ) {
		for( int j = 1;j <= m;j ++ ) last[j] = 0;
		int l = ( i - 1 ) * B + 1, ans = 0;
		for( int j = l;j <= n;j ++ ) {
			if( ! last[A[j]] ) last[A[j]] = j;
			else ans = max( ans, j - last[A[j]] );
			if( j % B == 0 ) len[i][block[j]] = ans; 
		}
	}
	for( int i = 1;i <= n;i ++ ) pos[A[i]].push_back( i );
	while( Q -- ) {
		int l, r;
		scanf( "%d %d", &l, &r );
		int ans = len[block[l] + 1][block[r] - 1];
		for( int i = l;i <= min( r, block[l] * B );i ++ ) {
			int p = lower_bound( pos[A[i]].begin(), pos[A[i]].end(), r ) - pos[A[i]].begin() - 1;
			if( ! ~ p ) continue;
			else ans = max( ans, pos[A[i]][p] - i );
		}
		for( int i = max( l, ( block[r] - 1 ) * B + 1 );i <= r;i ++ ) {
			int p = lower_bound( pos[A[i]].begin(), pos[A[i]].end(), l ) - pos[A[i]].begin();
			if( p == pos[A[i]].size() ) continue;
			else ans = max( ans, i - pos[A[i]][p] );
		}
		printf( "%d\n", ans );
	}
	return 0;
}

Children Trips

source

solution

先dfs确定每个点到根的距离$dis$以及深度$dep$

按$c$与$\sqrt{n}$的大小关系分块

• $c>\sqrt{n}$

  对于$u,v$，找到其$lca$，暴力一次一次跳，一次最多跳$p$长度，最多跳$\sqrt{n}$次

  最后得到跳的次数以及距离$lca$的距离，两个距离合在一起看是再跳一次还是两次

• $c\le \sqrt{n}$

  这个时候就不能暴力跳了，因为可能会达到$n$级别

  但是$c$最多只有$\sqrt{n}$个取值

  将排序按$c$从小到大排序，预处理倍增数组$g_{i,j}:$ 点$i$跳$2^j$​次所达到的点

按理来说$O(n\sqrt{n}\log n)$有点尴尬，但这道题是八秒，交上去倒是挺快的，╮(╯▽╰)╭

code

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define Pair pair < int, int >
#define maxn 100005
int n, m, B;
vector < Pair > G[maxn];
int dis[maxn], dep[maxn], ans[maxn];
int f[maxn][20], g[maxn][20];

void dfs( int u, int fa ) {
	f[u][0] = fa, dep[u] = dep[fa] + 1;
	for( int i = 1;i <= 16;i ++ )
		f[u][i] = f[f[u][i - 1]][i - 1];
	for( int i = 0;i < G[u].size();i ++ ) {
		int v = G[u][i].first;
		int w = G[u][i].second;
		if( v == fa ) continue;
		else dis[v] = dis[u] + w, dfs( v, u );
	}
}

struct node {
	int u, v, p, id;
	node(){}
	node( int U, int V, int P, int ID ) { u = U, v = V, p = P, id = ID; }
}block_little[maxn], block_large[maxn];

int get_lca( int u, int v ) {
	if( dep[u] < dep[v] ) swap( u, v );
	for( int i = 16;~ i;i -- ) 
		if( dep[f[u][i]] >= dep[v] ) 
			u = f[u][i];
	if( u == v ) return u;
	for( int i = 16;~ i;i -- ) 
		if( f[u][i] ^ f[v][i] ) 
			u = f[u][i], v = f[v][i];
	return f[u][0];
}

int jump_once( int u, int p ) {
	int t = u;
	for( int i = 16;~ i;i -- ) {
		if( dis[u] - dis[f[t][i]] > p ) continue;
		else t = f[t][i];
	}
	return t;
}

Pair climb_large( int u, int lca, int p ) {
	int cnt = 0;
	while( u ^ lca ) {
		int t = jump_once( u, p );
		if( dep[t] > dep[lca] ) cnt ++, u = t;
		else break;
	}
	return make_pair( cnt, dis[u] - dis[lca] );
}

void solve_large( int n ) {
	for( int i = 1;i <= n;i ++ ) {
		int u = block_large[i].u;
		int v = block_large[i].v;
		int p = block_large[i].p;
		int id = block_large[i].id;
		int lca = get_lca( u, v );
		Pair l = climb_large( u, lca, p );
		Pair r = climb_large( v, lca, p );
		int len = l.second + r.second;
		ans[id] = l.first + r.first + ( int )ceil( len * 1.0 / p );
	}
}

Pair climb_little( int u, int lca, int p ) {
	int cnt = 0;
	for( int i = 16;~ i;i -- )
		if( dep[g[u][i]] > dep[lca] ) 
			cnt += 1 << i, u = g[u][i];
	return make_pair( cnt, dis[u] - dis[lca] );
}

void build( int p ) {
	for( int i = 1;i <= n;i ++ ) g[i][0] = jump_once( i, p );
	for( int j = 1;j <= 16;j ++ )
		for( int i = 1;i <= n;i ++ )
			g[i][j] = g[g[i][j - 1]][j - 1];
}

void solve_little( int n ) {
	sort( block_little + 1, block_little + n + 1, []( node x, node y ) { return x.p < y.p; } );
	for( int i = 1;i <= n;i ++ ) {
		int u = block_little[i].u;
		int v = block_little[i].v;
		int p = block_little[i].p;
		int id = block_little[i].id;
		int lca = get_lca( u, v );
		if( p != block_little[i - 1].p ) build( p );
		Pair l = climb_little( u, lca, p );
		Pair r = climb_little( v, lca, p );
		int len = l.second + r.second;
		ans[id] = l.first + r.first + ( int )ceil( len * 1.0 / p );
	}
}

int main() {
	scanf( "%d", &n );
	for( int i = 1, u, v, w;i < n;i ++ ) {
		scanf( "%d %d %d", &u, &v, &w );
		G[u].push_back( make_pair( v, w ) );
		G[v].push_back( make_pair( u, w ) ); 
	}
	dfs( 1, 0 );
	B = sqrt( n );
	scanf( "%d", &m );
	int little = 0, large = 0;
	for( int i = 1, u, v, p;i <= m;i ++ ) {
		scanf( "%d %d %d", &u, &v, &p );
		if( p <= B ) block_little[++ little] = node( u, v, p, i );
		else block_large[++ large] = node( u, v, p, i );
	}
	solve_large( large );	
	solve_little( little );
	for( int i = 1;i <= m;i ++ ) printf( "%d\n", ans[i] );
	return 0;
}