优雅的暴力——树上启发式合并
优雅程度能和莫队分庭抗礼了
树上启发式合并
启发式合并，是一种基于人类直觉的优化方法。
在永无乡那个题中已经证过了
树上启发式合并，在树上按照子树大小来合并子问题求解
证明
我们反过来考虑，如果你写了一个启发式合并。我是一个弱智出题人，认为这个算法是错误的，想要卡掉你，我会怎么卡。肯定是尽量把你合并轻子树的次数卡的尽量多，那我假设当前子树节点有 \(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;
}
学了一晚上点分治没学会，结果把树上启发式合并学会了……
