最小割最小割边

#include <cstdio>//最小割，图的割边，割断后无法从源点到汇点，最小割边的容量和为该图的最大流；
#include <cstring>//最大点权独立和=所有点的权值和-最小割
#include <algorithm>//点即是边，拆点，拆边
#include <iostream>
#include <queue>
using namespace std;
#define LL long long
const LL INF=0x3f3f3f3f;
const LL mod=200010;
LL f[1000010],n,m,cont,arr[1010][1010],dis[1000010],gap[1000010],first[1000010];
LL cur[1000010];//当前弧
LL exc[1000010];//该点盈余
LL pre[1000010];//前驱节点
struct Node
{
    LL u,v,w;
    LL next;
}x[1000010];

void add_edge(LL a,LL b,LL value)
{
    x[cont].u=a,x[cont].v=b,x[cont].w=value;
    x[cont].next=first[a],first[a]=cont++;
    x[cont].u=b,x[cont].v=a,x[cont].w=0;
    x[cont].next=first[b],first[b]=cont++;
}
LL SAP(LL s,LL e,LL N)//源点，汇点，总点数
{
    LL Max_flow=0,u=s;
    pre[s]=-1;
    exc[s]=INF;
    memset(gap,0,sizeof(gap));//标号是i的点的个数
    memset(dis,0,sizeof(dis));//距离标号
    gap[0]=N;
    for(LL i=0; i<=N; i++) //初始化当前弧
        cur[i]=first[i];
    while(dis[s]<N)
    {
        LL flag=1;
        if(u==e)//找到汇点
        {
            Max_flow+=exc[e];//更新最大流
            for(LL i=pre[e]; i!=-1; i=pre[i]) //更新当前允许路
            {
                LL id=cur[i];
                x[id].w-=exc[e];
                x[id^1].w+=exc[e];
                exc[i]-=exc[e];
                if(x[id].w==0) u=i;//退回到容量为0的弧尾
            }
        }
        for(LL i=cur[u]; i!=-1; i=x[i].next) //从当前弧开始寻找允许弧
        {
            LL v=x[i].v;
            if(x[i].w>0&&dis[u]==dis[v]+1)//找到允许弧
            {
                flag=0;//找到允许弧
                cur[u]=i;//更新当前弧
                pre[v]=u;//记录前驱
                exc[v]=min(exc[u],x[i].w);//计算最大增广
                u=v;
                break;
            }
        }
        if(flag)//没有找到允许弧
        {
            if(--gap[dis[u]]==0) break;//出现断层结束
            LL minn=N;
            cur[u]=first[u];
            for(LL i=first[u]; i!=-1; i=x[i].next) //找离当前点可到达的最小层次
            {
                LL v=x[i].v;
                if(x[i].w>0&&dis[v]<minn)
                {
                    minn=dis[v];
                    cur[u]=i;//修改当前弧标记
                }
            }
            dis[u]=minn+1;//更新该点层次
            gap[dis[u]]++;//层次点数++
            if(u!=s) u=pre[u];//回溯继续寻找允许弧
        }
    }
    return Max_flow;
}
void init()
{
    memset(first,-1,sizeof(first));
    cont=0;
}
LL X[110][110];
LL z[4][2]={1,0,0,1,-1,0,0,-1};
LL vis[10010];
int main()
{
    LL ncase;
    scanf("%lld",&ncase);
    for(int k=1;k<=ncase;k++)
    {
        init();
        scanf("%lld%lld",&n,&m);
        LL s=0ll,t=n-1;
        for(int i=0;i<m;i++)
        {
            LL a,b,c,d;
            scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
            add_edge(a,b,c);
            if(d)
            {
                add_edge(b,a,c);
            }
        }
        LL ans=SAP(s,t,t+1);//求出最大流
        for(int i=0;i<cont;i+=2)//最小割一定是流量一定是满的，但满的边不一定是最小割
        {
            if(x[i].w==0)//满的边赋值为1
            {
                x[i].w=1;
                //x[i^1].w=0;
            }
            else//否则inf
            {
                x[i].w=INF;
                //x[i^1].w=0;
            }
        }
        ans=SAP(s,t,t+1);//再一次最大流就是答案
        printf("Case %d: %lld\n",k,ans);//还有一种方法，给每条边的容量*比较大的值+1最后对这个数取余就是答案
    }
}

题目链接戳这里
题目大致意思就是给你一个图让求从0到n-1最少需要割断几条边（在最小割的基础上）。输入每组4个数a,b,c,d.代表从a到b权值为c，d为1代表无向边，0代表有向边。