网络流

最新推荐文章于 2023-02-06 20:18:15 发布
最新推荐文章于 2023-02-06 20:18:15 发布
阅读量417 收藏 1
点赞数
分类专栏： 笔记 -图论 文章标签： 网络流 最大流 费用流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangche0526/article/details/56510207
版权

网络流

最大流

描述

在图中，给出每条边的最大流，求出从一给定源点到汇点的最大流

算法

单纯的贪心法由于搜索顺序会导致结果不同的问题并不能保证求出正确的答案，只需要将原始贪心算法中加入一个“反悔”机制就可以保证求出正确答案

实现中只需要加入反向边，没流过一条边，就将这条边的边权减去流量，并把反向边的边权加上这个流量

实际上就是通过加入反向边实现抵消操作

Ford-Fulkerson

dfs

时间复杂度： O(FE)

Edmonds-Karp

bfs优化

时间复杂度： O(E2V)

Dinic

每次找一条路前，先通过一次bfs更新每个点的level，目的是在之后的dfs中优先遍历深度浅的点

加入当前弧优化，避免对一条没有用的便进行多次检查

时间复杂度： O(EV2) 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int MAXN=10005,MAXM=100005,INF=~0U>>1;

int N,M,S,T;

struct E{int next,to,cap;} e[MAXM<<1];
int ecnt=1,G[MAXN];
void addEdge(int u,int v,int c)
{
    e[++ecnt]=(E){G[u],v,c};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0};G[v]=ecnt;
}

int dfn[MAXN];
queue<int> que;
bool calDfn()
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
            if(e[i].cap>0&&dfn[e[i].to]<0)
            {
                int v=e[i].to;
                dfn[v]=dfn[u]+1;
                que.push(v);
            }
    }
    return dfn[T]>-1;
}

int iter[MAXN];
int calF(int u,int f)
{
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]>dfn[u])
        {
            int res=calF(v,min(f,e[i].cap));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
    return 0;
}

int maxFlow()
{
    int i,flow=0;
    while(calDfn())
    {
        for(i=1;i<=N;i++) iter[i]=G[i];
        int f;
        while((f=calF(S,INF))>0)
            flow+=f;
    }
    return flow;
}

int main()
{
    int i;
    scanf("%d%d%d%d",&N,&M,&S,&T);
    for(i=1;i<=M;i++)
    {
        int u,v,w;scanf("%d%d%d",&u,&v,&w);
        addEdge(u,v,w);
    }
    printf("%d",maxFlow());
}

[网络流24题] 搭配飞行员 [COGS14]

题目描述

飞行大队有若干个来自各地的驾驶员，专门驾驶一种型号的飞机，这种飞机每架有两个驾驶员,需一个正驾驶员和一个副驾驶员。由于种种原因，例如相互配合的问题，有些驾驶员不能在同一架飞机上飞行，问如何搭配驾驶员才能使出航的飞机最多。

1

如图，假设有10个驾驶员，如图中的V1，V2，…，V10就代表达10个驾驶员,其中V1，V2，V3，V4，V5是正驾驶员,V6，V7，V8，V9，V10是副驾驶员。如果一个正驾驶员和一个副驾驶员可以同机飞行，就在代表他们两个之间连一条线,两个人不能同机飞行，就不连。例如V1和V7可以同机飞行，而V1和V8就不行。请搭配飞行员，使出航的飞机最多。注意:因为驾驶工作分工严格,两个正驾驶员或两个副驾驶员都不能同机飞行.

输入格式
输入文件有若干行
第一行，两个整数n与n1，表示共有n个飞行员(2<=n<=100),其中有n1名飞行员是正驾驶员.
下面有若干行,每行有2个数字a,b。表示正驾驶员a和副驾驶员b可以同机飞行。
注:正驾驶员的编号在前,即正驾驶员的编号小于副驾驶员的编号.

输出格式
输出文件有一行
第一行，1个整数，表示最大起飞的飞机数。

样例

flyer.in

10 5
1 7
2 6
2 10
3 7
4 8
5 9

flyer.out

4

裸题， 加源汇，全赋一，最大流。

#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;

const int MAXV=205,MAXE=MAXV*MAXV,INF=~0U>>1;

int n,n1,S,T;
struct E{int next,to,cap;} e[MAXE<<1];
int ecnt=1,G[MAXV];
void addEdge(int u,int v,int c)
{
    e[++ecnt]=(E){G[u],v,c};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0};G[v]=ecnt;
}
int dfn[MAXV];
queue<int> que;
bool calDfn()
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dfn[v]==-1)
                dfn[v]=dfn[u]+1,que.push(v);
        }
    }
    return dfn[T]!=-1;
}

int iter[MAXV];
int calF(int u,int f)
{
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]==dfn[u]+1)
        {
            int res=calF(v,min(f,e[i].cap));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
}

int maxFlow()
{
    int i,res=0;
    while(calDfn())
    {
        int f;for(i=1;i<=T;i++) iter[i]=G[i];
        while((f=calF(S,INF))>0)
            res+=f;
    }
    return res;
}

int main()
{
    freopen("flyer.in","r",stdin);
    freopen("flyer.out","w",stdout);
    int i,a,b;
    scanf("%d%d",&n,&n1);
    S=n+1,T=n+2;
    for(i=1;i<=n1;i++) addEdge(S,i,1);
    for(i=n1+1;i<=n;i++) addEdge(i,T,1);
    while(scanf("%d%d",&a,&b)!=EOF) addEdge(a,b,1);
    printf("%d\n",maxFlow());
    return 0;
}

[网络流24题] 太空飞行计划 [COGS727]

题目描述

W 教授正在为国家航天中心计划一系列的太空飞行。每次太空飞行可进行一系列商业性实验而获取利润。现已确定了一个可供选择的实验集合E={E1,E2,…,Em}，和进行这些实验需要使用的全部仪器的集合I={ I1, I2,…,In }。实验Ej 需要用到的仪器是I的子集Rj∈I。配置仪器Ik 的费用为ck 美元。实验Ej 的赞助商已同意为该实验结果支付pj 美元。W教授的任务是找出一个有效算法，确定在一次太空飞行中要进行哪些实验并因此而配置哪些仪器才能使太空飞行的净收益最大。这里净收益是指进行实验所获得的全部收入与配置仪器的全部费用的差额。

对于给定的实验和仪器配置情况，编程找出净收益最大的试验计划。

输入格式

第1行有2个正整数m和n(m,n <= 100)。m是实验数，n是仪器数。接下来的m行，每行是一个实验的有关数据。第一个数赞助商同意支付该实验的费用；接着是该实验需要用到的若干仪器的编号。最后一行的n个数是配置每个仪器的费用。

输出格式

第1行是实验编号；第2行是仪器编号；最后一行是净收益。

样例

shuttle.in

2 3
10 1 2
25 2 3
5 6 7

shuttle.out

1 2
1 2 3
17

只要收入大于成本那么实验就可以做，故从源点每个实验连一条 cap 为收入的边，从每个实验仪器向汇点连一条 cap 为费用的边，这样，跑出的最大流就是总的花费了。

答案要求输出选择的实验和实验仪器，那么对于所有最后一次还能遍历到的点，说明其可以选择，则输出。最后的净利润即为总收益减去总花费。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;

const int MAXV=205,MAXE=4e4+205,INF=~0U>>1;

int m,n,S,T;

struct E{int next,to,cap;} e[MAXE<<1];int ecnt=1,G[MAXV];
void addEdge(int u,int v,int c)
{
    e[++ecnt]=(E){G[u],v,c};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0};G[v]=ecnt;
}

int dfn[MAXV];
queue<int> que;
bool calDfn()
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dfn[v]==-1)
                dfn[v]=dfn[u]+1,que.push(v);
        }
    }
    return dfn[T]!=-1;
}
int iter[MAXV];
int calF(int u,int f)
{
    int i;
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]==dfn[u]+1)
        {
            int res=calF(v,min(f,e[i].cap));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
    return 0;
}

int dinic()
{
    int i,f,res=0;
    while(calDfn())
    {
        for(i=1;i<=T;i++) iter[i]=G[i];
        while((f=calF(S,INF))>0) res+=f;
    }
    return res;
}


int main()
{
    freopen("shuttle.in","r",stdin);
    freopen("shuttle.out","w",stdout);
    int i,j,x,sum=0;
    scanf("%d%d",&m,&n);
    S=m+n+1,T=S+1;
    for(i=1;i<=m;i++)
    {
        scanf("%d",&x);addEdge(S,i,x);sum+=x;
        while(getchar()==' ')
            scanf("%d",&x),addEdge(i,x+m,INF);
    }
    for(i=1;i<=n;i++) scanf("%d",&x),addEdge(i+m,T,x);
    int ans=sum-dinic();
    for(i=1;i<=m;i++) if(dfn[i]!=-1) printf("%d ",i);putchar('\n');
    for(i=1;i<=n;i++) if(dfn[i+m]!=-1) printf("%d ",i);putchar('\n');
    printf("%d\n",ans);
    return 0;
}

最小割

最大流=最小割

最大流的变体

多个源点和汇点

增加一个超级源点s和一个超级汇点t，从s向每个源点加入一条容量无穷的边，从每一个汇点向t加入一条容量无穷的边

无向图

加两条边即可

顶点上流量限制

把结点“割开”，所有入边连到一点A上，所有出边连到一点B上，从A向B连一条cap为该结点流量限制的边即可

费用流

每条边上通过单位流量需要一定费用

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int MAXN=5005,MAXM=50005,INF=~0U>>1;

int N,M,S,T;

int minCost,maxFlow;

struct E{int next,to,cap,cost;} e[MAXM<<1];
int ecnt=1,G[MAXN];
void addEdge(int u,int v,int c,int w)
{
    e[++ecnt]=(E){G[u],v,c,w};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0,-w};G[v]=ecnt;
}

int pre[MAXN];//pre:最短路中来的边

int dis[MAXN];bool inQ[MAXN];
queue<int> que;
bool SPFA()
{
    int i;
    for(i=1;i<=N;i++) dis[i]=INF;
    memset(inQ,false,sizeof(inQ));
    inQ[S]=true,dis[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dis[v]>dis[u]+e[i].cost)
            {
                dis[v]=dis[u]+e[i].cost;
                pre[v]=i;
                if(!inQ[v])
                {
                    inQ[v]=true;
                    que.push(v);
                }
            }
        }
        inQ[u]=false;
    }
    return dis[T]!=INF;
}

void calc()
{
    int f=INF,u;
    for(u=T;u!=S;u=e[pre[u]^1].to) f=min(f,e[pre[u]].cap);
    for(u=T;u!=S;u=e[pre[u]^1].to) e[pre[u]].cap-=f,e[pre[u]^1].cap+=f;
    minCost+=f*dis[T];
    maxFlow+=f;
}

int main()
{
    int i;
    scanf("%d%d%d%d",&N,&M,&S,&T);
    for(i=1;i<=M;i++)
    {
        int u,v,c,w;scanf("%d%d%d%d",&u,&v,&c,&w);
        addEdge(u,v,c,w);
    }
    while(SPFA()) calc();
    printf("%d %d\n",maxFlow,minCost);
    return 0;
}

[网络流24题] 运输问题 [COGS739]

时间限制：1 s 内存限制：128 MB

题目描述

题目描述

对于给定的 m 个仓库和 n 个零售商店间运送货物的费用，计算最优运输方案和最差运输方案。

输入格式

输入格式

输出格式

程序运行结束时，将计算出的最少运输费用和最多运输费用输出到文件 tran.out 中。

tran.in

2 3
220 280
170 120 210
77 39 105
150 186 122

tran.out

48500
69140

对于所有数据： 1≤N,M≤100

裸题，只需从原点到仓库连边，商店到汇点连边，前两种边带 cap ，商店向汇点连带费用的边，然后跑费用流即可。

至于最大费用，把费用设为负的跑费用流即可，注意不要用 Dijkstra 了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int MAXV=205,MAXE=MAXV*(MAXV+2),INF=~0U>>1;

int n,m,S,T;
int minCost;
struct E{int next,to,cap,cost;};
struct CFS
{
    E e[MAXE<<1];
    int ecnt,G[MAXV];
    void addEdge(int u,int v,int c,int w)
    {
        e[++ecnt]=(E){G[u],v,c,w};G[u]=ecnt;
        e[++ecnt]=(E){G[v],u,0,-w};G[v]=ecnt;
    }
    CFS(){ecnt=1;}
} G[2];
int pre[MAXV];

bool inQ[MAXV];int dis[MAXV];queue<int> que;
bool SPFA(int flag)
{
    CFS & rG=G[flag>0];
    int i;
    memset(inQ,false,sizeof(inQ));
    for(i=1;i<=m+n+1;i++) dis[i]=INF;
    dis[S]=0;que.push(S);inQ[S]=true;
    while(!que.empty())
    {
        int u=que.front();que.pop();
        inQ[u]=false;
        for(i=rG.G[u];i;i=rG.e[i].next)
        {
            int v=rG.e[i].to;
            if(rG.e[i].cap>0&&dis[v]>dis[u]+rG.e[i].cost*flag)
            {
                dis[v]=dis[u]+rG.e[i].cost*flag;
                pre[v]=i;
                if(!inQ[v]) inQ[v]=true,que.push(v);
            }
        }
    }
    return dis[T]!=INF;
}

void calc(int flag)
{
    CFS & rG=G[flag>0];
    int f=INF,u;
    for(u=T;u!=S;u=rG.e[pre[u]^1].to) 
        f=min(f,rG.e[pre[u]].cap);
    for(u=T;u!=S;u=rG.e[pre[u]^1].to) 
        rG.e[pre[u]].cap-=f,rG.e[pre[u]^1].cap+=f;
    minCost+=f*dis[T];
}

int main()
{
    freopen("tran.in","r",stdin);
    freopen("tran.out","w",stdout);
    int i,j,c,w;
    scanf("%d%d",&m,&n);
    S=0,T=n+m+1;
    //
    for(i=1;i<=m;i++)
        scanf("%d",&c),G[1].addEdge(S,i,c,0);
    for(i=1;i<=n;i++)
        scanf("%d",&c),G[1].addEdge(i+m,T,c,0);
    for(i=1;i<=m;i++)
        for(j=1;j<=n;j++)
            scanf("%d",&w),G[1].addEdge(i,j+m,INF,w);
    G[0]=G[1];
    //
    minCost=0;
    while(SPFA(1)) 
        calc(1);
    printf("%d\n",minCost);
    minCost=0;
    while(SPFA(-1))
        calc(-1);
    printf("%d\n",-minCost);
    return 0;
}

有上下界的网络流

无源汇可行流

流程：

  1. 添加附加源点 S ，附加汇点 T ，将所有上界与下界之差作为 cap 值；
  2. 统计每个点的 nodeFlow ，入度为正，出度为负；
  3. 对于每个节点 u ：
    • 若 nodeFlow 为正，从 S 到 u 建立一条 cap 为 nodeFlow 的边
    • 若 nodeFlow 为负，从 u 到 T 建立一条 cap 为 -nodeFlow 的边
  4. 从 S 到 T 跑最大流，对于每条边，其可行流为流量下界加上最大流中流过的流量。
模板题
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#define min(a,b) (a<b?a:b)
using namespace std;

const int MAXN=205,MAXM=40010,INF=~0U>>1;

int n,m,S,T;
int lower[MAXM],nodeFlow[MAXN];//in:+ out:-
int ans[MAXM];
struct E{int next,to,cap,id;} e[MAXM<<1];
int ecnt=1,G[MAXN];
void addEdge(int u,int v,int c,int id)
{
    e[++ecnt]=(E){G[u],v,c,id};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0,0};G[v]=ecnt;
}
int dfn[MAXN];
queue<int> que;
bool calDfn()
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dfn[v]==-1)
                dfn[v]=dfn[u]+1,que.push(v);
        }
    }
    return dfn[T]!=-1;
}
int iter[MAXN];
int calF(int u,int f)
{
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]==dfn[u]+1)
        {
            int res=calF(v,min(f,e[i].cap));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
    return 0;
}
void dinic()
{
    while(calDfn())
    {
        for(int i=1;i<=T;i++) iter[i]=G[i];
        while(calF(S,INF)>0);
    }
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    int i,u,v,l,r;
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&u,&v,&l,&r);
        addEdge(u,v,r-l,i);
        lower[i]=l,nodeFlow[u]-=l,nodeFlow[v]+=l;
    }
    S=n+1,T=n+2;
    for(i=1;i<=n;i++)
    {
        if(nodeFlow[i]>0) addEdge(S,i,nodeFlow[i],0);
        else if(nodeFlow[i]<0) addEdge(i,T,-nodeFlow[i],0);
    }
    dinic();
    bool ok=true;
    for(i=G[S];i;i=e[i].next)
        if(e[i].cap>0) {ok=false;break;}
    if(ok)
    {
        printf("YES\n");
        for(i=2;i<=ecnt;i++)
            ans[e[i].id]=e[i^1].cap;
        for(i=1;i<=m;i++) printf("%d\n",ans[i]+lower[i]);
    }else printf("NO\n");
    return 0;
}

有源汇可行流

添加一条从 t 到 s 的 cap 为 INF 的边，按无源汇跑即可。

有源汇最大流

按照无源汇可行流建图，添加一条从 t 到 s 的 cap 为 INF 的边，跑 S 到 T 的最大流，判断是否满流，若是，再跑一次 s 到 t 的最大流即为答案。
模板题

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int MAXN=405,MAXM=20005,INF=~0U>>1;

int n,m;
struct E{int next,to,cap;} e[MAXM<<1];
int ecnt=1,G[MAXN];
void addEdge(int u,int v,int c)
{
    e[++ecnt]=(E){G[u],v,c};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0};G[v]=ecnt;
}
int nodeFlow[MAXN],flowSum=0;

queue<int> que;
int dfn[MAXN];
bool calDfn(int S,int T)
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dfn[v]==-1)
                dfn[v]=dfn[u]+1,que.push(v);
        }
    }
    return dfn[T]!=-1;
}

int iter[MAXN];
int calF(int u,int T,int f)
{
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]==dfn[u]+1)
        {
            int res=calF(v,T,min(e[i].cap,f));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
    return 0;
}

int dinic(int S,int T)
{
    int i,f,res=0;
    while(calDfn(S,T))
    {
        for(i=1;i<=n+2;i++) iter[i]=G[i];
        while((f=calF(S,T,INF))>0) res+=f;
    }
    return res;
}

int main()
{
    int i,s,t,S,T;
    scanf("%d%d%d%d",&n,&m,&s,&t);
    S=n+1,T=n+2;
    for(i=1;i<=m;i++)
    {
        int u,v,l,r;scanf("%d%d%d%d",&u,&v,&l,&r);
        addEdge(u,v,r-l);
        nodeFlow[u]-=l,nodeFlow[v]+=l;
    }
    for(i=1;i<=n;i++)
    {
        if(nodeFlow[i]>0) addEdge(S,i,nodeFlow[i]),flowSum+=nodeFlow[i];
        else if(nodeFlow[i]<0) addEdge(i,T,-nodeFlow[i]);
    }
    addEdge(t,s,INF);
    int mustFlow=dinic(S,T);
    if(mustFlow==flowSum) printf("%d\n",dinic(s,t));
    else printf("please go home to sleep\n");
    return 0;
}

有源汇最小流

按照无源汇可行流建图，先跑 S 到 T 的最大流，再添加一条从 t 到 s 的 cap 为 INF 的边，在残余网络上跑第二次 S 到 T 的最大流，判断是否满流，若是，第二次的流量即为最小流。

模板题
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
typedef long long ll;
using namespace std;

const int MAXN=1e5+5,MAXM=5e5,INF=~0U>>1;

int n,m;

struct E{int next,to,cap;} e[MAXM<<1];
int ecnt=1,G[MAXN];
void addEdge(int u,int v,int c)
{
    e[++ecnt]=(E){G[u],v,c};G[u]=ecnt;
    e[++ecnt]=(E){G[v],u,0};G[v]=ecnt;
}
ll nodeFlow[MAXN];

int dfn[MAXN];
queue<int> que;
bool calDfn(int S,int T)
{
    int i;
    memset(dfn,-1,sizeof(dfn));
    dfn[S]=0;que.push(S);
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(i=G[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].cap>0&&dfn[v]==-1)
                dfn[v]=dfn[u]+1,que.push(v);
        }
    }
    return dfn[T]!=-1;
}

int iter[MAXN];
ll calF(int u,int T,ll f)
{
    if(u==T) return f;
    for(int & i=iter[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(e[i].cap>0&&dfn[v]==dfn[u]+1)
        {
            ll res=calF(v,T,min(f,(ll)e[i].cap));
            if(res>0)
            {
                e[i].cap-=res,e[i^1].cap+=res;
                return res;
            }
        }
    }
    return 0;
}

ll dinic(int S,int T)
{
    int i;ll f,res=0;
    while(calDfn(S,T))
    {
        for(i=1;i<MAXN;i++) iter[i]=G[i];
        while((f=calF(S,T,INF))>0) res+=f;
    }
    return res;
}

int main()
{
    freopen("data.in","r",stdin);
    int i,s,t,S,T;
    scanf("%d%d%d%d",&n,&m,&s,&t);
    S=n+1,T=n+2;
    for(i=1;i<=m;i++) 
    {
        int u,v,l,r;scanf("%d%d%d%d",&u,&v,&l,&r);
        addEdge(u,v,r-l);
        nodeFlow[u]-=l,nodeFlow[v]+=l;
    }
    ll flowSum=0;
    for(i=1;i<=n;i++)
    {
        if(nodeFlow[i]>0) addEdge(S,i,nodeFlow[i]),flowSum+=nodeFlow[i];
        else if(nodeFlow[i]<0) addEdge(i,T,-nodeFlow[i]);
    }
    ll f1=dinic(S,T);
    addEdge(t,s,INF);
    ll f2=dinic(S,T);
    if(f1+f2==flowSum) printf("%lld\n",f2);
    else printf("please go home to sleep\n");
    return 0;
}
zhangche0526
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络流详解
05-30
全网最详细的网络流介绍
网络编程中的网络流，文本流，文件流（中软国际 Seventh Day）
lrttester的专栏
11-23 1038
                                                      网络流、文本流、文件流 在网络编程中，常用的流有网流、文本流、文件流。网络流用于传输数流;文本流用于读写文本;文件流用于读写文件;1.网络流：NetworkStream类提供用于网络访问的基础流，NetworkStream实现了通过网络套接字发送和接收数据的标准.Net框架流机制
网络流算法
weixin_43226045的博客
05-30 2421
网络流算法 很多实际问题可以建模为流网络 • 装配线上物件的流动 • 电网中电流的流动 • 通信网络中信息的流动 • 道路交通网络中的运输活动 • …… • 一个源节点s、一个汇点t，由源节点流向汇点 • 流量守恒 • 流网络 是一个无自环的有向图G=(V, E)， (1) 图中的每条边(u, v)E有一个非负的容量值c(u, v)0。 if (u, v)E c(u, v)=0； (2) ...
网络流专题（最大流与费用流）例题总结
qq_35975367的博客
01-15 2646
文章目录NC 106056 poj1459 Power Network题目大意：题解：NC213817 [网络流24题]最小路径覆盖问题题目：题解：例2：NC213818 [网络流24题]魔术球问题题目：题解：方法2：NC 213820 [网络流24题]最长递增子序列问题题目:题解：NC19939 [CQOI2015]网络吞吐量题目： NC 106056 poj1459 Power Network 题目大意： 总共有n个节点，其中有发电站np个、用户nc个和调度器n-np-nc个三种节点，每个发电站有一个最
MATLAB 网络流
小嗷犬的博客
02-06 2091
本文介绍了如何使用 MATLAB 解决最大流问题。
网络流——最大流
Wlis的博客
11-27 4125
一、什么是网络流 网络流是指给定一个有向图，其中有两个特殊的点：源点sss（Source）和汇点ttt（Sink）；每条边都有一个指定的流量上限，下文均称之为容量（Capacity），即经过这条边的流量不能超过容量，这样的图被称为网络流图。同时，除了源点和汇点外，所有点的入流和出流都相等，源点只有流出的流，汇点只有流入的流，网络流就是从 sss 到 ttt 的一个可行流。 二、可行流、最大流 定义...
网络流matlab代码(最大流).zip
07-11
网络流matlab代码
网络流介绍
08-10
网络流全套学习资料
求大网络流的C++实现
12-22
　在这个工程中，网络上的点分为已标号点和未标号点。将起始点标号，其他刚开始未标号。从起始点开始，利用广度优先算法进行遍历，找到一个未标号点时，看临接的标号点与之是正向边还是反向边，以此来进行相应的...
网络流dinic模板
02-24
网络流dinic模板，非本人原创。网络流dinic模板，非本人原创
对偶图及其应用
Virgil's Blog
05-11 9069
对偶图及其应用模型每个平面图 GG 都有一个与之对偶的平面图 G∗ G∗ 有如下性质： G∗中的每个点对应 GG 中的一个面 对于 GG 中的，每条边 ee ee 属于两个面 f1,f2f_1,f_2 ，加入边 (f∗1,f∗2)(f_1^*,f_2^*) ee 只属于一个面 ff ，加入回边 (f∗,f∗)(f^*,f^*) （图中加入了个绿色边围成的面，需要删除 s∗s
仙人掌相关问题的处理方法（未完待续）
Virgil's Blog
05-13 7764
仙人掌相关问题的处理方法如图所示：仙人掌图就是长得像仙人掌的图嘛（我真没看出哪里像了）定义：对一个无向连通图，任意一条边属于至多一个简单环。 桥边：非环边，就是连接环的那些边； 环边：就是环中的边嘛。 在仙人掌上，父亲和儿子都有节点的和环的之分。DFS 树解决仙人掌 DP 问题仙人掌的处理是十分复杂的（本蒟蒻个人认为，神犇轻喷），这里先从简单的 DFS树开始。 树边：DFS 树中存在的边 非树边：D
图论中的二分
Virgil's Blog
04-30 1079
图论中的二分 图论中最基础的算法是最短路，然而近些年在竞赛中已很少考最短路问题，许多图论题目往往是要求一种十分诡异的东西，这时候我们想直接求是不现实的，二分答案就应运而生了。
平衡树比较与应用
Virgil's Blog
06-19 1030
两种平衡树比较与应用
Pólya 定理（草稿）
Virgil's Blog
05-28 978
Polya 定理Polya 定理常在算法竞赛中用于解决计数问题。 首先介绍一下理解此定理需要的数学基础：群给定集合 G={a,b,c,…}G=\{a,b,c,\dots\} 和集合 GG 上的二元运算 ∗* ，如果满足：运算 ∗* 是封闭的且是可结合的；存在单位元 ee 和逆元（ aa 的逆元记为 a−1a^{-1} ），则称集合 GG 在运算 ∗* 下是一个群，记为 (G,∗)(G,*) 。置换
计数与递推
Virgil's Blog
08-02 853
基础组合数学理论应用[POJ1737]Connected Graph 给定 nn ，求有 nn 个节点的连通图个数。 n≤50n\leq 50 直接计算答案并不容易，我们考虑求出所有的可能性后减去不连通的个数。设 f(n)f(n) 为 nn 个节点的连通图个数（答案）， g(n)g(n) 为 nn 个节点的非连通图个数， h(n)h(n) 为 nn 个节点的图的个数。对于 h(n)h(
基础动态规划
Virgil's Blog
05-03 817
基础动态规划 线性动规 最短路径 paths A Spy in the Metro 小奇挖矿 Remember the Word 最优构造树 树上动规 软件安装 柠檬当上了警察局长 区间动规
弦图（草稿）
Virgil's Blog
07-24 595
弦图与区间图1. 图论基本概念1.1 子图子图 subgraph图 G=(V,E)G=(V,E) ，则 G′=(V′,E′),V′⊆V,E′⊆EG'=(V',E'),V'\subseteq V,E'\subseteq E 为图 GG 的子图。诱导子图 induced subgraph图 G=(V,E)G=(V,E) ，则 G′=(V′,E′),V′⊆V,E′={(u,v)∣u,v∈V′,(u,v)∈
matlab 实现 网络流
最新发布
11-13
MATLAB可以通过使用Graph和相关工具箱实现网络流问题。首先，需要创建一个图对象来表示网络流问题中的流网络。然后，可以利用Graph和相关函数来表示网络中的节点和边，并且给定它们的容量和流量。 接着，可以利用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值