网络流——洛谷P1344 [USACO4.4]追查坏牛奶Pollutant Control

https://www.luogu.org/problem/show?pid=1344
看到一中超级流弊的方法

可以将题目转化模型， 就是求割边最少的最小割， 其实是套路题， 把边的权值全部乘以一个较大的数E再加1， 网络流的答案ans;
那么ans/E, ans%E, 分别就是两问的答案了， 其实就是对于原图中相同的最小割， 在新图上跑最小割时， 对于在原图上相同的代价， 新图会选取尽量少的割边也就是加上的”一”尽量少；代码显然很好实现

对于这个E
我们为了让ans/E不受影响，我们让E=m+1
这样的话答案就一定正确

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#define Ll long long
using namespace std;
const Ll N=1e4+5;
struct cs{Ll to,nxt,v;}a[N*20];
Ll head[N],ll=1,cur[N];
Ll q[N],l,r;
Ll deep[N];
Ll n,m,S,E,x,y,z,ans,six=1000+1;
void init(Ll x,Ll y,Ll z){a[++ll].to=y;a[ll].v=z;a[ll].nxt=head[x];head[x]=ll;}
bool bfs(){
    memset(deep,0,sizeof deep);//这个其实可以优化的，我不会 
    q[1]=S;l=r=1;deep[S]=1;
    for(;r>=l;l++){//当前弧优化赋值↓ 
        Ll x=q[l];cur[x]=head[x];if(x==E)return 1;//发现跟就可以退出了 
        for(Ll k=head[x];k;k=a[k].nxt)
            if(!deep[a[k].to]&&a[k].v!=0)
                deep[a[k].to]=deep[x]+1,q[++r]=a[k].to;
    }return 0;
}
Ll dfs(Ll x,Ll now){//now代表当前x的可用流 
    if(x==E)return now; 
    Ll ans=0; 
    for(Ll &k=cur[x];k;k=a[k].nxt)//只访问一次 
        if(deep[a[k].to]-1==deep[x]&&a[k].v){//这个优化a[k].v会快的 
            Ll temp=dfs(a[k].to,min(a[k].v,now));
            now-=temp; ans+=temp;
            a[k].v-=temp; a[k^1].v+=temp;//反向边 
            if(!now)break;//优化 
        }return ans;
}
int main()
{
    scanf("%lld%lld",&n,&m);
    S=1;E=n;
    for(Ll i=1;i<=m;i++){
        scanf("%lld%lld%lld",&x,&y,&z);
        z=z*six+1;
        init(x,y,z);init(y,x,0);
    }
    while(bfs())ans+=dfs(S,1e9);
    printf("%lld %lld",ans/six,ans%six);
}

然后标准做法就是边权从大到小一条一条处理