bzoj2561 最小生成树

Description

给定一个边带正权的连通无向图G=(V,E)，其中N=|V|，M=|E|，N个点从1到N依次编号，给定三个正整数u，v，和L (u≠v)，假设现在加入一条边权为L的边(u,v)，那么需要删掉最少多少条边，才能够使得这条边既可能出现在最小生成树上，也可能出现在最大生成树上？　

Input

第一行包含用空格隔开的两个整数，分别为N和M；
接下来M行，每行包含三个正整数u，v和w表示图G存在一条边权为w的边(u,v)。
最后一行包含用空格隔开的三个整数，分别为u，v，和 L；
数据保证图中没有自环。

Output

输出一行一个整数表示最少需要删掉的边的数量。

Sample Input

3 2
3 2 1
1 2 3
1 2 2

Sample Output

1

HINT

对于20%的数据满足N ≤ 10，M ≤ 20，L ≤ 20；
对于50%的数据满足N ≤ 300，M ≤ 3000，L ≤ 200；
对于100%的数据满足N ≤ 20000，M ≤ 200000，L ≤ 20000。

 

正解：最小割。

讲道理这题并不难，但是我完全没往最小割那方面去想，于是做不出。。

我们知道，要使$(u,v,w)$在最小生成树上，必须割掉边权小于$w$的一些边，使得$u,v$不连通，最大生成树同理。

于是我们对于小于$w$的边连起来，跑一遍最小割，大于$w$的同理。两个最小割加起来，就是答案了。

 

//It is made by wfj_2048~
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define inf (1<<30)
#define N (500010)
#define il inline
#define RG register
#define ll long long
#define File(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)

using namespace std;

struct edge{ int nt,to,flow,cap; }g[N];
struct E{ int u,v,w; }e[N];

int head[N],d[N],q[N],n,m,u,v,w,num,ans;

il int gi(){
    RG int x=0,q=1; RG char ch=getchar();
    while ((ch<'0' || ch>'9') && ch!='-') ch=getchar();
    if (ch=='-') q=-1,ch=getchar();
    while (ch>='0' && ch<='9') x=x*10+ch-48,ch=getchar();
    return q*x;
}

il void insert(RG int from,RG int to,RG int cap){
    g[++num]=(edge){head[from],to,0,cap},head[from]=num; return;
}

il int cmp(const E &a,const E &b){ return a.w<b.w; }

il int bfs(RG int S,RG int T){
    memset(d,0,sizeof(d));
    RG int h=0,t=1; q[t]=S,d[S]=1;
    while (h<t){
    RG int x=q[++h],v;
    for (RG int i=head[x];i;i=g[i].nt){
        v=g[i].to;
        if (!d[v] && g[i].cap>g[i].flow){
        d[v]=d[x]+1,q[++t]=v;
        if (v==T) return 1;
        }
    }
    }
    return 0;
}

il int dfs(RG int x,RG int T,RG int a){
    if (x==T || !a) return a; RG int v,f,flow=0;
    for (RG int i=head[x];i;i=g[i].nt){
    v=g[i].to;
    if (d[v]==d[x]+1 && g[i].cap>g[i].flow){
        f=dfs(v,T,min(a,g[i].cap-g[i].flow));
        if (!f){ d[v]=-1; continue; }
        g[i].flow+=f,g[i^1].flow-=f;
        flow+=f,a-=f; if (!a) break;
    }
    }
    return flow;
}

il int maxflow(RG int S,RG int T){
    RG int flow=0;
    while (bfs(S,T)) flow+=dfs(S,T,inf);
    return flow;
}

il void work(){
    n=gi(),m=gi();
    for (RG int i=1;i<=m;++i) e[i].u=gi(),e[i].v=gi(),e[i].w=gi();
    u=gi(),v=gi(),w=gi(),sort(e+1,e+m+1,cmp),num=1;
    for (RG int i=1;i<=m;++i){
    if (e[i].w>=w) break;
    insert(e[i].u,e[i].v,1),insert(e[i].v,e[i].u,1);
    }
    ans+=maxflow(u,v),memset(head,0,sizeof(head)),num=1;
    for (RG int i=m;i;--i){
    if (e[i].w<=w) break;
    insert(e[i].u,e[i].v,1),insert(e[i].v,e[i].u,1);
    }
    ans+=maxflow(u,v); printf("%d\n",ans); return;
}

int main(){
    File("tree");
    work();
    return 0;
}