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;
}