hdu 5432 Minimum Cut 树链剖分nlogn

给你一棵树，树上一些节点间会连额外的边，问只切一条树上的边，使整个图分为两部分，最少要切多少条边。

因为限定了树上要切一条边，那么答案就是对于每条边，求被切开的两棵树之间连边的数量

对于一条额外的连边ab，要使它变成连接两棵树的一条边，那么只可能是切掉了 a->b链上的一条边，也就是说a->b链上的每条边都影响这条额外的边

按这个思路，我们就可以求出树上每条边影响的额外边的数目，就是要将图分开两部分，切掉这条边后还需切掉的边数。

于是对于每条额外的连边ab，更新a->b链上的每条边的边权，就会想到树链剖分。

但是这题直接用nlog^2n的树链剖分会T，这题的一个特点是不用你在线求每条边影响的数目，只需要全部更新结束后求一下求整棵树上边权的最小值。

那么我们其实不用每次都用线段树更新每一部分，只要在要更新的区间开头+1，末尾-1，最后求一个总和，中间记录下最小值就可以了。

复杂度降到nlogn

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 20005;
int n;
int head[maxn],nxt[maxn*2],cap[maxn*2],ce;
void addEdge(int x,int y){
cap[ce]=y;
nxt[ce]=head[x];
head[x]=ce++;
}

int hson[maxn],f[maxn],cnt[maxn],far[maxn];
void predfs(int x){
cnt[x]=1;
hson[x]=0;
for(int i=head[x];i!=-1;i=nxt[i]) if(f[x]!=cap[i]){
int son = cap[i];
far[son]=far[x]+1;
f[son]=x;
predfs(son);
cnt[x]+=cnt[son];
if(cnt[son]>cnt[hson[x]]) hson[x]=son;
}
}
int p[maxn],c=0,r[maxn];
void dfs(int x,int root){
r[x]=root;
p[x]=c++;
if(hson[x]) dfs(hson[x],root);
for(int i=head[x];i!=-1;i=nxt[i]) if(f[x]!=cap[i]&&hson[x]!=cap[i]){
dfs(cap[i],cap[i]);
}
}
int cc[maxn];
void update(int x,int y){
while(r[x]!=r[y]){
if(far[r[x]]>far[r[y]]) swap(x,y);
cc[p[r[y]]]++;    //更新变成了O(1)
cc[p[y]+1]--;
y=f[r[y]];
}
if(x==y) return;
if(far[x]>far[y]) swap(x,y);
cc[p[x]+1]++;
cc[p[y]+1]--;
}

int main(){
int t,m,a,b,ca=0;
cin>>t;
while(t--){
c=ce=0;
memset(cc,0,sizeof(cc));
memset(f,-1,sizeof(f));
memset(head,-1,sizeof(head));

cin>>n>>m;
int ret=m;
for(int i=0;i<n-1;i++) {
scanf("%d%d",&a,&b);
addEdge(a,b);
addEdge(b,a);
}
predfs(1);
dfs(1,1);
m-=n-1;
while(m--){
scanf("%d%d",&a,&b);
update(a,b);
}
int tmp=0;
for(int i=1;i<n;i++){
tmp+=cc[i];  //其实是利用了dfs序，求了每个入边的值
ret=min(ret,tmp);
}
printf("Case #%d: %d\n",++ca,ret+1);
}
return 0;
}