网络流（最大流、最小费用最大流、有上下界的网络流）

最新推荐文章于 2023-01-07 13:58:42 发布

XerxesSimon

最新推荐文章于 2023-01-07 13:58:42 发布

阅读量5k

点赞数 1

分类专栏： ACM-ICPC 2016暑期特训1

本文链接：https://blog.csdn.net/XerxesSimon/article/details/52159627

版权

ACM-ICPC 2016暑期特训1 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

最大流的算法：

Ford-Fulkerson算法

求最大流的过程，就是不断找到一条源到汇的路径，然后构建残余网络，再在残余网络上寻找新的路径，使总流量增加，然后形成新的残余网络，再寻找新路径…..直到某个残余网络上找不到从源到汇的路径为止，最大流就算出来了。

每次寻找新流量并构造新残余网络的过程，就叫做寻找流量的“增广路径”，也叫“增广”

现在假设每条边的容量都是整数

这个算法每次都能将流至少增加1

由于整个网络的流量最多不超过图中所有的边的容量和C，从而算法会结束

现在来看复杂度找增广路径的算法可以用dfs，

复杂度为边数m+顶点数n Dfs 最多运行C次所以时间复杂度为C*(m+n) =C* n^

http://acm.hdu.edu.cn/showproblem.php?pid=1532

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+107;
const int inf=0x3f3f3f3f;
struct node{
    int to;//终点
    int cap;//容量
    int rev;//反向边
};
vector<node> v[N];
bool used[N];
void add(int from,int to,int cap)
{
    v[from].push_back((node) {to,cap ,v[to].size()    });
    v[to].push_back((node)   {from,0 ,v[from].size()-1});
}
int dfs(int s,int t,int f)
{
    if(s==t) return f;
    used[s]=true;
    for(int i=0;i<v[s].size();i++)
    {
        node &tmp=v[s][i];
        if(used[tmp.to]==false&&tmp.cap>0)
        {
            int d=dfs(tmp.to,t,min(f,tmp.cap));
            if(d>0)
            {
//                tmp.cap-=d;
                v[s][i].cap-=d;
                v[tmp.to][tmp.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    while(1)
    {
        memset(used,false,sizeof(used));
        int f=dfs(s,t,inf);
        if(f==0) return flow;
        flow+=f;
    }
}
int main()
{
    int n,m,i,j,k,t;
    while(~scanf("%d%d",&n,&m))
    {
        memset(v,0,sizeof(v));
        for(i=0;i<n;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
        }
        printf("%d\n",max_flow(1,m));
    }
    return 0;
}

Dinic 算法

Edmonds-Karp的提高余地：需要多次从s到t调用BFS，可以设法减少调用次数。 

亦即：使用一种代价较小的高效增广方法。 

考虑：在一次增广的过程中，寻找多条增广路径。 

DFS

Dinic算法的实现有以下几个步骤：

1：初始化容量网络和网络流

2：构造残留网络和层次网络，若汇点不在层次网络中则算法结束输出最大流

3：在层次网络中用一次DFS进行增广，DFS执行完毕，该阶段的增广也就完毕了。

4：转至步骤2

#include<bits/stdc++.h>
using namespace std;
const int N=205;
const int M=100010;
const int inf=0x3f3f3f3f;
int n,m,si,ei,ci;
int level[N];
struct node{
    int c,f;
}mp[N][N];
bool dinic_bfs()
{
    queue<int> q;
    memset(level,0,sizeof level);
    q.push(1);
    level[1]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int v=1;v<=m;v++)
        if(!level[v]&&mp[u][v].c>mp[u][v].f)
        {
            level[v]=level[u]+1;
            q.push(v);
        }
    }
    return level[m]!=0;
}
int dinic_dfs(int u,int cp)
{
    int tmp=cp;
    if(u==m) return cp;
    for(int v=1;v<=m&&tmp;v++)
    if(level[u]+1==level[v])
    {
        if(mp[u][v].c>mp[u][v].f)
        {
            int t=dinic_dfs(v,min(tmp,mp[u][v].c-mp[u][v].f));
            mp[u][v].f+=t;
            mp[v][u].f-=t;
            tmp-=t;
        }
    }
    return cp-tmp;
}
int dinic()
{
    int sum=0,tf=0;
    while(dinic_bfs())
    {
        while(tf=dinic_dfs(1,inf))
        {
            sum+=tf;
        }
    }
    return sum;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(mp,0,sizeof mp);
        while(n--)
        {
            scanf("%d%d%d",&si,&ei,&ci);
            mp[si][ei].c+=ci;
        }
        printf("%d\n",dinic());
    }
    return 0;

最小费用最大流

1.求出从发点到收点的最小费用路u(s,t)

2.对该通路u(s,t)分配最大可能的流量：f

并让通路上所有边的容量相应减少f。这时，对于通路上的饱和边，其单位流费用相应改为 +无穷

3.作该通路u(s,t)上所有边（i,j)的反向边（j,i),令

4.在这样构成的新网络中，重复上述步骤1，2，3，到从发点到收点全部流量等于f为止（或者再也找不到从S到T 的最小费用通路）。

反复用spfa算法做源到汇的最短路进行增广，边权值为边上单位费用。反向边上的单位费用是负的。

直到无法增广，即为找到最小费用最大流。

成立原因：每次增广时，每增加1个流量，所增加的费用都是最小的。

因为有负权边（取消流的时候产生的），所以不能用迪杰斯特拉算法求最短路。

http://poj.org/problem?id=2135

//#include<bits/stdc++.h>
#include<iostream>
#include<queue>
#include<stdio.h>
#include<stdlib.h>
#include<cstring>
using namespace std;
const int N=1050;
const int M=40050;
const int inf=0x3f3f3f3f;
struct node{
    int from,to,flow,cap,cost;
    node(){}
    node(int a,int b,int c,int d,int e)
    {
        from=a;to=b;flow=c;cap=d;cost=e;
    }

};
vector<int> g[N];
vector<node> mp;
void add(int a,int b,int c,int d)
{
    mp.push_back(node(a,b,0,c,d));
    mp.push_back(node(b,a,0,0,-d));
    int total=mp.size();
    g[a].push_back(total-2);
    g[b].push_back(total-1);
}
int dis[N],P[N],A[N];
bool used[N];
int m,n,flow,cost;
bool spfa(int s,int t)
{
    memset(dis,inf,sizeof dis);
    memset(used,0,sizeof used);
    dis[s]=0;used[s]=1;P[s]=0;A[s]=inf;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        used[u]=0;
        for(int i=0;i<g[u].size();i++)
        {
            node tmp=mp[g[u][i]];
            if(tmp.cap>tmp.flow&&dis[tmp.to]>dis[u]+tmp.cost)
            {
                dis[tmp.to]=dis[u]+tmp.cost;
                P[tmp.to]=g[u][i];
                A[tmp.to]=min(A[u],tmp.cap-tmp.flow);
                if(!used[tmp.to]) q.push(tmp.to),used[tmp.to]=1;
            }
        }
    }
    if(dis[t]==inf) return 0;
    flow+=A[t];
    cost+=dis[t]*A[t];
    int u=t;
    while(u!=s){
        mp[P[u]].flow+=A[t];
        mp[P[u]^1].flow-=A[t];
        u=mp[P[u]].from;
    }
    return 1;
}
int mincost(int s,int t)
{
    flow=cost=0;
    while(spfa(s,t));
    return cost;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(g,0,sizeof g);
        mp.clear();
        int s=0,t=n+1,u,v,c;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&c);
            add(u,v,1,c);
            add(v,u,1,c);
        }
        add(s,1,2,0);
        add(n,t,2,0);
        printf("%d\n",mincost(s,t));
    }
    return 0;
}

有上下界的网络流

1、无源汇有上下界最大流

解题思路：O（-1）。

建图模型：以前写的最大流默认的下界为0，而这里的下界却不为0，所以我们要进行再构造让每条边的下界为0，这样做是为了方便处理。对于每根管子有一个上界容量up和一个下界容量low，我们让这根管子的容量下界变为0，上界为up-low。可是这样做了的话流量就不守恒了，为了再次满足流量守恒，即每个节点"入流=出流”，我们增设一个超级源点st和一个超级终点sd。我们开设一个数组du[]来记录每个节点的流量情况。

du[i]=in[i]（i节点所有入流下界之和）-out[i]（i节点所有出流下界之和）。

当du[i]大于0的时候，st到i连一条流量为du[i]的边。

当du[i]小于0的时候，i到sd连一条流量为-du[i]的边。

最后对（st，sd）求一次最大流即可，当所有附加边全部满流时（即maxflow==所有du[]>0之和），有可行解。

题目链接： sgu194 Reactor Cooling

#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;


const int maxn=1000+10;
const int INF=0x7FFFFFFF;

struct Edge
{
    int from,to,cap,flow,up,low;
};
vector<Edge>edges;
vector<int>G[maxn];
bool vis[maxn];
int d[maxn];
int cur[maxn];
int Out[maxn],In[maxn];
int s,t;

//求出层次网络
bool BFS()
{
    memset(vis,0,sizeof(vis));
    queue<int>Q;
    Q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!Q.empty())
    {
        int x=Q.front();
        Q.pop();
        for(int i=0; i<G[x].size(); i++)
        {
            Edge& e=edges[G[x][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[x]+1;
                Q.push(e.to);
            }
        }
    }
    return vis[t];
}


//加边
void AddEdge(int from,int to,int low,int up)
{
    int m;
    Edge r;
    r.from=from;
    r.to=to;
    r.cap=up-low;
    r.flow=0;
    r.low=low;
    r.up=up;
    edges.push_back(r);
    Edge d;
    d.from=to;
    d.to=from;
    d.cap=0;
    d.flow=0;
    //r.low=low;r.up=up;
    edges.push_back(d);
    m=edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

//每个阶段来一次DFS增广
int DFS(int x,int a)
{
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int i=cur[x]; i<G[x].size(); i++)
    {
        Edge& e=edges[G[x][i]];
        if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
        {
            e.flow+=f;
            edges[G[x][i]^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}

//多个阶段，多次建立层次网络。
int Maxflow(int ss,int tt)
{
    int flow=0;
    while(BFS())
    {
        memset(cur,0,sizeof(cur));
        flow+=DFS(ss,INF);
    }
    return flow;
}


int main()
{
    int N,M,i,j;
    while(~scanf("%d%d",&N,&M))
    {

        edges.clear();
        for(int i=0; i<maxn; i++) G[i].clear();
        memset(In,0,sizeof(In));
        memset(Out,0,sizeof(Out));
        s=0;
        t=N+1;

        for(i=1; i<=M; i++)
        {
            int u,v,low,up;
            scanf("%d%d%d%d",&u,&v,&low,&up);
            AddEdge(u,v,low,up);
            In[v]=In[v]+low;
            Out[u]=Out[u]+low;
        }

        for(i=1; i<=N; i++)
        {
            AddEdge(i,t,0,Out[i]);
            AddEdge(s,i,0,In[i]);
        }

        Maxflow(s,t);

        int flag=1;
        for(i=0; i<edges.size(); i++)
            if(edges[i].from==s)
                if(edges[i].flow<edges[i].cap)
                {
                    flag=0;
                    break;
                }
        if(!flag) printf("NO\n");
        else
        {
            printf("YES\n");
            for(i=0; i<2*M; i++)
                if(i%2==0)
                    printf("%d\n",edges[i].flow+edges[i].low);
        }
    }
    return 0;
}

2、有源汇有上下界的最大流

解题思路：增设一源点st，汇点sd，st到第i天连一条上界为Di下界为0的边，每个女神到汇点连一条下界为Gi上界为oo的边，对于每一天，当天到第i个女孩连一条[Li，Ri]的边。

建图模型：源点s，终点d。超级源点ss，超级终点dd。首先判断是否存在满足所有边上下界的可行流，方法可以转化成无源汇有上下界的可行流问题。怎么转换呢？

增设一条从d到s没有下界容量为无穷的边，那么原图就变成了一个无源汇的循环流图。接下来的事情一样，超级源点ss连i（du[i]>0），i连超级汇点（du[i]<0）,

对（ss，dd）进行一次最大流，当maxflow等于所有(du[]>0)之和时，有可行流，否则没有。

当有可行流时，删除超级源点ss和超级终点dd，再对（s，d）进行一次最大流，此时得到的maxflow则为题目的解。为什么呢？因为第一次maxflow（）只是求得所有满足下界的流量，而残留网络（s，d）路上还有许多自由流（没有和超级源点和超级汇点连接的边）没有流满，所有最终得到的maxflow=（第一次流满下界的流+第二次能流通的自由流）。

题目： http://poj.org/problem?id=2396

讲解：http://blog.csdn.net/water_glass/article/details/6823741

#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
#define maxM 50000
#define maxN 500
#define inf 1<<30
struct node{
int u,v,f,next;
}edge[maxM];
int head[maxN],p,lev[maxN],cur[maxN];
int que[maxM],tre[maxN],up[maxN][50],low[maxN][50];
void init1(int n,int m){
p=0,memset(head,-1,sizeof(head)),memset(tre,0,sizeof(tre));
for(int i=0;i<=n;i++) for(int j=0;j<=m;j++)
up[i][j]=inf,low[i][j]=0;
}
bool bfs(int s,int t){
int qin=0,qout=0,u,i,v;
memset(lev,0,sizeof(lev));
lev[s]=1,que[qin++]=s;
while(qout!=qin){
u=que[qout++];
for(i=head[u];i!=-1;i=edge[i].next){
if(edge[i].f>0 && lev[v=edge[i].v]==0){
lev[v]=lev[u]+1,que[qin++]=v;
if(v==t) return 1;
}
}
}
return lev[t];
}
int dinic(int s,int t){
int qin,u,i,k,f;
int flow=0;
while(bfs(s,t)){
memcpy(cur,head,sizeof(head));
u=s,qin=0;
while(1){
if(u==t){
for(k=0,f=inf;k<qin;k++)
if(edge[que[k]].f<f)
f=edge[que[i=k]].f;
for(k=0;k<qin;k++)
edge[que[k]].f-=f,edge[que[k]^1].f+=f;
flow+=f,u=edge[que[qin=i]].u;
}
for(i=cur[u];cur[u]!=-1;i=cur[u]=edge[cur[u]].next)
if(edge[i].f>0 && lev[u]+1==lev[edge[i].v]) break;
if(cur[u]!=-1)
que[qin++]=cur[u],u=edge[cur[u]].v;
else{
if(qin==0) break;
lev[u]=-1,u=edge[que[--qin]].u;
}
}
}
return flow;
}
void addedge(int u,int v,int f){
edge[p].u=u,edge[p].v=v,edge[p].f=f,edge[p].next=head[u],head[u]=p++;
edge[p].u=v,edge[p].v=u,edge[p].f=0,edge[p].next=head[v],head[v]=p++;
}
bool buit(int n,int m){
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(low[i][j]>up[i][j]) return 0;
else{
tre[i]-=low[i][j],tre[j+n]+=low[i][j];
addedge(i,j+n,up[i][j]-low[i][j]);
}
return 1;
}
void limitflow(int s,int t,int n,int m){
int i,j,x,y;
x=t+1,y=t+2;
for(i=0;i<=t;i++){
if(tre[i]>0) addedge(x,i,tre[i]);
else if(tre[i]<0) addedge(i,y,-tre[i]);
}
addedge(t,s,inf);
dinic(x,y);
for(i=head[x];i!=-1;i=edge[i].next)
if(edge[i].f){
printf("IMPOSSIBLE\n\n"); return ;
}
for(i=head[t];i!=-1;i=edge[i].next)
if(edge[i].v==s) break;
if(i<0){
printf("IMPOSSIBLE\n\n"); return;
}
for(i=1;i<=n;i++){
for(j=1;j<m;j++)
printf("%d ",edge[((i-1)*m+j)*2-1].f+low[i][j]);
printf("%d\n",edge[i*m*2-1].f+low[i][j]);
}
printf("\n");
}
int main(){
int cas,cas1,n,m,i,j,sum1,sum2;
int u,v,d,f1,t1,f2,t2,s,t;
char c[5];
scanf("%d",&cas);
for(int tt=1;tt<=cas;tt++){
scanf("%d%d",&n,&m);
s=0,t=n+m+1,sum1=0,sum2=0;
init1(n,m);
for(i=1;i<=n;i++) scanf("%d",&u),tre[s]-=u,tre[i]+=u,sum1+=u;;
for(i=n+1;i<=n+m;i++) scanf("%d",&u),tre[i]-=u,tre[t]+=u,sum2+=u;
scanf("%d",&cas1);
while(cas1--){
scanf("%d%d%s%d",&u,&v,c,&d);
f1=t1=u,f2=t2=v;
if(u==0) f1=1,t1=n;
if(v==0) f2=1,t2=m;
for(i=f1;i<=t1;i++)
for(j=f2;j<=t2;j++){
if(c[0]=='='){
low[i][j]=max(d,low[i][j]),up[i][j]=min(d,up[i][j]);
}else if(c[0]=='>'){
low[i][j]=max(d+1,low[i][j]);
}else if(c[0]=='<'){
up[i][j]=min(d-1,up[i][j]);
}
}
}
if(sum1==sum2 && buit(n,m)) limitflow(s,t,n,m);
else printf("IMPOSSIBLE\n\n");
}
return 0;
}

3、有源汇有上下界的最小流

解题思路：

1、du[i]表示i节点的入流之和与出流之和的差。

2、增设超级源点st和超级汇点sd，连（st，du[i]（为正）），（-du[i]（为负），sd）。 ///增设超级源点和超级汇点，因为网络中规定不能有弧指向st，也不能有流量流出sd

3、做一次maxflow（）。

4、源点（Sd）和起点（St）连一条容量为oo的边。

5、再做一次maxflow（）。

6、当且仅当所有附加弧满载时有可行流，最后答案为flow[（Sd->St）^1]，St到Sd最大流就是Sd到St最小流。

http://acm.hdu.edu.cn/showproblem.php?pid=3157

/*
hdu 3157
poj 3801
题意：一个电路板，上面有N个接线柱(标号1~N) 还有两个电源接线柱 + -
然后是给出M个部件正负极的接线柱和最小电流
求一个可以让所有部件正常工作的总电流没有则输出impossible
其实就是一个有源汇有上下界最小流问题
处理有源汇有上下界最大流问题是：
1.构造附加网络
2.对ss、tt求最大流(ss、tt满流则有解)
3.若有解，对s、t求最大流
而有源汇有上下界最小流问题则是：
1.构造附加网络(不添加[t,s]边)
2.对ss、tt求最大流
3.添加[t,s]边
4.对ss、tt求最大流
5.若ss、tt满流，则[t,s]的流量就是最小流
这个代码大部分都是从别的题上摘过来的，注释有点乱
*/
#include<stdio.h>
#include<string.h>
#define inf 0x7fffffff
struct edge//边
{
int u,v,f,next,b,c;//边的前节点后节点可用流下条边的编号原来边上流的上下界
}e[1500];
int head[70],in[70],s,t,ss,tt,yong,sum;
int n,m;
void ini()
{
memset(head,-1,sizeof(head));
yong=0;
memset(in,0,sizeof(in));
s=0,t=n+1,ss=t+1,tt=ss+1;//各节点编号的安排
sum=0;
}
void adde(int from,int to,int xia,int shang)//加边
{ //加边
e[yong].u=from,e[yong].v=to,e[yong].f=shang-xia,e[yong].b=xia,e[yong].c=shang;
e[yong].next=head[from],head[from]=yong++;
//同时加它的退边
e[yong].u=to,e[yong].v=from,e[yong].f=0,e[yong].b=xia,e[yong].c=shang;
e[yong].next=head[to],head[to]=yong++;
}
void build()
{
int i;
for(i=0;i<=t;++i)
{
if(in[i]>0)
adde(ss,i,0,in[i]);
else
{
adde(i,tt,0,-in[i]);
sum+=(-in[i]);
}
}
}
int d[1000],num[1000];
int min(int a,int b){return a<b?a:b;}
int sap_gap(int u,int f,int s,int t)//递归sap
{
if(u==t)
return f;
int i,v,mind=t,last=f,cost;
for(i=head[u];i!=-1;i=e[i].next)
{
v=e[i].v;
int flow=e[i].f;
if(flow>0)//参考模版写的时候把flow写成了f
{
if(d[u]==d[v]+1)
{
cost=sap_gap(v,min(last,flow),s,t);
e[i].f-=cost;
e[i^1].f+=cost;
last-=cost;
if(d[s]>=t+1)
return f-last;
if(last==0)
break;
}
if(d[v]<mind)
mind=d[v];
}
}
if(last==f)
{
--num[d[u]];
if(num[d[u]]==0)
d[s]=t+1;
d[u]=mind+1;
++num[d[u]];
}
return f-last;
}
int max_f(int s,int t)
{
int f=0;
memset(d,0,sizeof(d));
memset(num,0,sizeof(num));
for(num[s]=t+1;d[s]<t+1;)
f+=sap_gap(s,inf,s,t);
return f;
}
int main()
{
int i,dat,u,v,f1,f2,p;
char from[10],to[10];
while(scanf("%d%d",&n,&m),n+m)
{
ini();
for(i=1;i<=m;++i)
{
scanf("%s%s%d",from,to,&dat);
if(from[0]=='+') u=s;
else sscanf(from,"%d",&u);
if(to[0]=='-') v=t;
else sscanf(to,"%d",&v);
adde(u,v,dat,inf);
in[u]-=dat,in[v]+=dat;
}
build();
f1=max_f(ss,tt);
p=yong;
adde(t,s,0,inf);
f2=max_f(ss,tt);
if(f1+f2!=sum) printf("impossible\n");
else printf("%d\n",e[p^1].f);
}
return 0;
}

XerxesSimon

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
网络流（最大流、最小费用最大流、有上下界的网络流）

最大流的算法：Ford-Fulkerson算法求最大流的过程，就是不断找到一条源到汇的路径，然后构建残余网络，再在残余网络上寻找新的路径，使总流量增加，然后形成新的残余网络，再寻找新路径…..直到某个残余网络上找不到从源到汇的路径为止，最大流就算出来了。每次寻找新流量并构造新残余网络的过程，就叫做寻找流量的“增广路径”，也叫“增广” 现在假设每条边的容量
复制链接

扫一扫