Solution -「Gym 102759I」Query On A Tree 17

$\mathcal{Description}$

  Link.

  给定一棵含 $n$ 个结点的树，结点 $1$ 为根，点 $u$ 初始有点权 $a_u=0$，维护 $q$ 次操作：

1. 给定 $u$，将 $u$ 子树内的点权加 $1$；
2. 给定 $u,v$，将 $u,v$ 简单路径上的点权加 $1$。

  每次操作后，求出树最靠近结点 $1$ 的带权重心。

  $n,q\le10^5$。

$\mathcal{Solution}$

  记点权和为 $S$，发现这么一个事情：

从 $1$ 开始任意 DFS 树，在经过点权和不小于 $\lceil\frac{S}{2}\rceil$ 时停止在结点 $x$，则带权重心为 $x$ 及其祖先中的某一个。

当然转化在 DFN 序列上更简洁

DFN 序列的前缀和恰好超过 $\lceil\frac{S}{2}\rceil$ 的位置就是上述 $x$ 的 DFN。

  证明上，这样的遍历把树分为一个点权和不小于 $\lceil\frac{S}{2}\rceil$ 的连通块 $A$ 和若干连通块 $B$。注意带权重心的基本性质是以重心为根时，不存在一条连向点权和大于 $\lfloor\frac{S}{2}\rfloor$ 的子树。首先考虑 $B$ 中的结点 $u$，若 $u$ 能成为重心，其父亲必然也能成为重心，而且其父亲更靠近 $1$，所以 $u$ 不优；对于 $A$ 中不是 $x$ 祖先的结点同理，所以证明了这条性质。

  回到本题，难点已经扫除了。树剖维护点权，线段树二分找到 $x$，倍增祖先找到重心即可。复杂度 $\mathcal O(q\log^2n)$。

$\mathcal{Code}$

/*~Rainybunny~*/

#include <cstdio>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

typedef long long LL;

const int MAXN = 1e5, MAXLG = 16;
int n, ecnt, head[MAXN + 5], ans = 1;
struct Edge { int to, nxt; } graph[MAXN * 2 + 5];
int fa[MAXN + 5][MAXLG + 5], siz[MAXN + 5], son[MAXN + 5], dep[MAXN + 5];
int dfc, dfn[MAXN + 5], top[MAXN + 5], ref[MAXN + 5];

inline void link( const int u, const int v ) {
	graph[++ecnt] = { v, head[u] }, head[u] = ecnt;
	graph[++ecnt] = { u, head[v] }, head[v] = ecnt;
}

inline void init( const int u ) {
	dep[u] = dep[fa[u][0]] + 1, siz[u] = 1;
	for ( int i = 1; fa[u][i - 1]; fa[u][i] = fa[fa[u][i - 1]][i - 1], ++i );
	for ( int i = head[u], v; i; i = graph[i].nxt ) {
		if ( ( v = graph[i].to ) != fa[u][0] ) {
			fa[v][0] = u, init( v ), siz[u] += siz[v];
			if ( siz[v] > siz[son[u]] ) son[u] = v;
		}
	}
}

inline void init( const int u, const int tp ) {
	top[u] = tp, ref[dfn[u] = ++dfc] = u;
	if ( son[u] ) init( son[u], tp );
	for ( int i = head[u], v; i; i = graph[i].nxt ) {
		if ( ( v = graph[i].to ) != fa[u][0] && v != son[u] ) {
			init( v, v );
		}
	}
}

struct SegmentTree {
	int len[MAXN << 2];
	LL sum[MAXN << 2], tag[MAXN << 2];
	
	inline void pushad( const int u, const LL v ) {
		sum[u] += len[u] * v, tag[u] += v;
	}
	
	inline void pushup( const int u ) {
		sum[u] = sum[u << 1] + sum[u << 1 | 1];
	}
	
	inline void pushdn( const int u ) {
		if ( tag[u] ) {
			pushad( u << 1, tag[u] ), pushad( u << 1 | 1, tag[u] );
			tag[u] = 0;
		}
	}
	
	inline void init( const int u, const int l, const int r ) {
		len[u] = r - l + 1;
		if ( l == r ) return ;
		int mid = l + r >> 1;
		init( u << 1, l, mid ), init( u << 1 | 1, mid + 1, r );
	}
	
	inline void add( const int u, const int l, const int r,
	  const int al, const int ar, const int v ) {
	  	if ( al <= l && r <= ar ) return pushad( u, v );
	  	int mid = l + r >> 1; pushdn( u );
	  	if ( al <= mid ) add( u << 1, l, mid, al, ar, v );
	  	if ( mid < ar ) add( u << 1 | 1, mid + 1, r, al, ar, v );
	  	pushup( u );
	}
	
	inline LL qsum( const int u, const int l, const int r,
	  const int ql, const int qr ) {
	  	if ( ql <= l && r <= qr ) return sum[u];
	  	int mid = l + r >> 1; LL ret = 0; pushdn( u );
	  	if ( ql <= mid ) ret += qsum( u << 1, l, mid, ql, qr );
	  	if ( mid < qr ) ret += qsum( u << 1 | 1, mid + 1, r, ql, qr );
	  	return ret;
	}
	
	inline int qhalf( const int u, const int l, const int r, const LL h ) {
		if ( l == r ) return l;
		int mid = l + r >> 1; pushdn( u );
		if ( sum[u << 1] >= h ) return qhalf( u << 1, l, mid, h );
		else return qhalf( u << 1 | 1, mid + 1, r, h - sum[u << 1] );
	}
} sgt;

inline void subtrAdd( const int u ) {
	sgt.add( 1, 1, n, dfn[u], dfn[u] + siz[u] - 1, 1 );
}

inline void chainAdd( int u, int v ) {
	while ( top[u] != top[v] ) {
		if ( dep[top[u]] < dep[top[v]] ) u ^= v ^= u ^= v;
		sgt.add( 1, 1, n, dfn[top[u]], dfn[u], 1 ), u = fa[top[u]][0];
	}
	if ( dep[u] < dep[v] ) u ^= v ^= u ^= v;
 	sgt.add( 1, 1, n, dfn[v], dfn[u], 1 );
}

inline void solve() {
	int u = ref[sgt.qhalf( 1, 1, n, sgt.sum[1] + 1 >> 1 )];
	per ( i, MAXLG, 0 ) {
		int v = fa[u][i];
		if ( v && sgt.qsum( 1, 1, n, dfn[v],
		  dfn[v] + siz[v] - 1 ) << 1 <= sgt.sum[1] ) {
			u = fa[v][0];
		}
	}
	if ( fa[u][0] && sgt.qsum( 1, 1, n, dfn[u],
	  dfn[u] + siz[u] - 1 ) << 1 <= sgt.sum[1] ) u = fa[u][0];
	printf( "%d\n", u );
}

int main() {
	scanf( "%d", &n );
	rep ( i, 2, n ) {
		int u, v; scanf( "%d %d", &u, &v );
		link( u, v );
	}
	
	init( 1 ), init( 1, 1 ), sgt.init( 1, 1, n );
	
	int q, op, u, v; scanf( "%d", &q );
	while ( q-- ) {
		scanf( "%d %d", &op, &u );
		if ( op == 1 ) subtrAdd( u );
		else scanf( "%d", &v ), chainAdd( u, v );		
		solve();
	}
	return 0;
}