优雅程度能和莫队分庭抗礼了

---

树上启发式合并

启发式合并，是一种基于人类直觉的优化方法。

在永无乡那个题中已经证过了

树上启发式合并，在树上按照子树大小来合并子问题求解

证明

我们反过来考虑，如果你写了一个启发式合并。我是一个弱智出题人，认为这个算法是错误的，想要卡掉你，我会怎么卡。肯定是尽量把你合并轻子树的次数卡的尽量多，那我假设当前子树节点有 \(k\) 个，并且不是重儿子，那我向上合并的时候，肯定是所有它的兄弟都是 \(k\) 个节点才能最大化合并轻儿子次数，不妨假设它没有兄弟，那么合并之后的树上共有\(2 \times k\)个点，同理再往上合并一层是 \(4 \times k\) 个节点，然后是 \(8 \times k\) 个节点，会发现这玩意是指数级增长的，但我们的节点总共只有 \(n\) 个，所以复杂度最多也就是 \(O(n\log n)\)

考虑这个题，把序列上按中点分治搬到树上，就是按 \(lca\) 分治，然后把启发式合并每个子树，用树状数组维护即可。（我就整不明白 \(lower\_bound\) 为什么是错的，然后换成\(upper\_bound\) 就对了……

#include <bits/stdc++.h>

using namespace std;

#define INF 1<<30
#define pb push_back
#define ill unsigned long long 
#define lowbit(x) (x&(-x))
const int mod = 2009;

template<typename _T>
inline void read(_T &x)
{
	x = 0;int f= 1;char s = getchar();
	while(s<'0'||s>'9'){f=1;if(s=='-')f=-1;s=getchar();}
	while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+s-'0';s=getchar();}
	x*=f;
}

int n;

const int np = 4e4 + 5;

int head[np],edge[np * 2], nxt[np * 2] ,ver[np * 2];
int siz[np],dep[np],son[np],b[np];
int tree[np + 5],_dep[np],fa[np],tit,k,Ans;
int *st , *en;

inline int query(int x)
{
	int res =0 ;
	while(x)
	{
		res += tree[x];
		x-=lowbit(x);
	}
	return res;
}

inline void add(int x,int c)
{
	while(x <= n + 1)
	{
		tree[x] += c;
		x+=lowbit(x); 
	}
}

inline void add(int a,int b,int c)
{
	ver[++tit] = b;
	edge[tit] = c;
	nxt[tit] = head[a];
	head[a] = tit;
}

inline void dfs(int x,int f)
{
	siz[x] = 1;
	fa[x] = f;
	for(int i=head[x],v,val;i;i=nxt[i]) 
	{
		v = ver[i];
		if(v == fa[x]) continue;
		dep[v] = dep[x] + edge[i];
		dfs(v,x);
		siz[x] += siz[v];
		if(siz[v] > siz[son[x]]) son[x] = v;
	}
}

inline void hb(int x,int lca)
{
	int lim = k  - dep[x] + 2 * dep[lca];
	int _lim = upper_bound(st,en , lim) - b;
	_lim--;
	if(lim > 0) Ans += query(_lim);
	for(int i=head[x],v;i;i=nxt[i])
	{
		v = ver[i];
		if(v == fa[x]) continue;
		hb(v,lca);
	}
}

inline void cancle_merge(int x,int typ)
{
	add(_dep[x], typ);
	for(int i=head[x],v;i;i=nxt[i])
	{
		v = ver[i];
		if(v == fa[x]) continue;
		cancle_merge(v,typ);
	}
}

inline void dsu(int x)
{
	for(int i=head[x],v;i;i=nxt[i])
	{
		v =ver[i];
		if(v == fa[x] || v == son[x]) continue;
		dsu(v);
	}
	if(son[x]) dsu(son[x]);
	int lim = k + dep[x];
	int _lim = upper_bound(st,en,lim) - b;
	_lim--;
	if(lim >  0) Ans += query(_lim) 
	add(_dep[x] , 1);
	for(int i=head[x],v;i;i=nxt[i])
	{
		v = ver[i];
		if(v == fa[x] || v == son[x]) continue;
		hb(v,x);
		cancle_merge(v,1);
	}	
	if(son[fa[x]] != x) cancle_merge(x , -1); 
}

signed main()
{
	read(n);

	for(int i=1,u,v,w;i<n;i++)
	{
		read(u);
		read(v);
		read(w);
		add(u,v,w);
		add(v,u,w);
	}
	
	dep[1] = 1;
	dfs(1 , 0);
	read(k);
	memcpy(b+1,dep+1,sizeof(dep));
	sort(b + 1,b + 1 + n);
	st = b + 1;
	en = unique(b+1,b+1+n);
	
	for(int i=1;i<=n;i++)
	{
		_dep[i] = lower_bound(st,en,dep[i]) - b;
	}

	dsu(1);
	
	cout<<Ans;
}

---

学了一晚上点分治没学会，结果把树上启发式合并学会了……