网络流入门

网络流

基本

是图论中的一个分支。可以把它看做水流的流输。
一张有向图。
源点：S；
就是所有水流流出点
汇点：T；
就是最终水流流入点。
x->y 边有一个容量值c（x，y）。可以理解为水管的最大运输量。
也有一个流值 f（x，y）。可以理解为水管现在的水流量。
c（x，y）- f（x，y）为剩余流量。
f(x,y)满足三个点：
1.容量限制：f（x,y）<=c(x,y)
2.斜对称：f(x,y)=-f（y，x）
3.流量守恒：对于x点，流入的量的总和=流出的量总和。
算法进阶指南上将他描述为：在不超过容量限制的前提下，流从源点出发，经过各条边，流入汇点。

最大流

就是水网中使流量最大的流方法。

Edmonds—Karp算法

当有一条路径，所有边的剩余容量都大于0，就可以算作一条增广路。
EK不断BFS,建立动态的网络流图，找到增广路，直到再也无法找到增广路。这时候的流量总和就是最大流。
注意：由于斜对称性，每条边有一个反向边，初始剩余流量为0。在bfs处理过程中，将增广路的边减去流，将其反向边加上流。
其使用规模大约是10^3~10^4.

模板

#include<bits/stdc++.h>
using namespace std;
const int M=1e9+10;
int n,m,t=1,ans=0; 
int inf[1010]={},pre[1010]={};
bool vis[1010]={};
struct edge 
{
    int y,next,v;
}a[1000010];
int linkk[1010]={}; 
void insert(int x,int y,int v)//t初始值为1，每条边xor 1 后就是其反向边。 
{
    a[++t].y=y;a[t].next=linkk[x];a[t].v=v;linkk[x]=t;
    a[++t].y=x,a[t].next=linkk[y];a[t].v=0;linkk[y]=t;
}
void init()
{
    scanf("%d%d",&n,&m);
    int x,y,v;
    for(int i=1;i<=n;++i)
      {
        scanf("%d%d%d",&x,&y,&v);
        insert(x,y,v);
      }
}
bool bfs()//可以spfa优化 
{
    queue<int> q;
    memset(vis,0,sizeof(vis));
    q.push(1);//加入源点 
    vis[1]=1; 
    inf[1]=M;
    while (q.size())
      {
        int x=q.front();q.pop();
        for(int i=linkk[x];i;i=a[i].next)
          if (a[i].v)
            {
                int y=a[i].y;
                if (vis[y]) continue;
                inf[y]=min(inf[x],a[i].v);
                pre[y]=i;q.push(y);vis[y]=1;
                if (y==m) return 1;//搜到汇点。 
            }
      }
    return 0;
}
void updata()
{
    int x=m,c=inf[m];
    while (x!=1)//回溯 
      {
        int i=pre[x];
        a[i].v-=c;
        a[i^1].v+=c;//流两边处理 
        x=a[i^1].y;
      }
    ans+=c;
}
void work()
{
    while (bfs()) updata();
    printf("%d",ans);
}
int main()
{
    init();
    work(); 
    return 0;
} 

dinic算法

dinic算法还是更常用一点，同时也相对更难敲一点。
分层图
在bfs时，每个点有一个深度顺序，将相同顺序的点放在同一层中
dinic在bfs时将整张图按照深度建立一张分层图，在这张分层图上dfs，求增广路，并且回溯时更新剩余容量。
差不多可以处理10^4~10^5这么大的网络

模板

#include<bits/stdc++.h>
using namespace std;
const int M=1e9;
int m,n,t=1,ans=0,head,tail;
struct edge 
{
    int y,next,v;
}a[1000010];
int linkk[1010]={},dep[1010]={},q[2010]={};
inline int read()
{
    int num=0;char c=getchar();
    for(;c<'0'||c>'9';c=getchar());
    for(;c<='9'&&c>='0';c=getchar()) num=(num<<1)+(num<<3)+c-48;
    return num;
}
void insert(int x,int y,int v)
{
    a[++t].y=y;a[t].v=v;a[t].next=linkk[x];linkk[x]=t;
    a[++t].y=x;a[t].v=0;a[t].next=linkk[y];linkk[y]=t;
    return ;//建立双向流量边 
}
void init()
{
    n=read();
    m=read();
    int x,y,v;
    for(int i=1;i<=n;++i)
      {
        x=read();y=read();v=read();
        insert(x,y,v);
      }
    return ;
}
bool bfs()
{
    memset(dep,0,sizeof(dep));
    head=0;tail=1;
    q[1]=1;
    dep[1]=1;
    while (++head<=tail)
      {
        int x=q[head];
        for(int i=linkk[x];i;i=a[i].next)
          if (a[i].v&&!dep[a[i].y])//无流量边被忽略，已处理点不处理。 
            {
                int y=a[i].y;
                dep[y]=dep[x]+1;
                q[++tail]=y;
                if (y==m) return 1;
            }
      }
    return 0;
}
int dinic(int x,int flow)
{
    if (x==m) return flow;
    int rest=flow,k;
    for(int i=linkk[x];i&&rest;i=a[i].next)
      if (a[i].v)
      {
        int y=a[i].y;
        if (dep[y]!=dep[x]+1) continue;
        k=dinic(y,min(rest,a[i].v));
        if (!k) dep[y]=0;//这条边上找不到增广路了，就删除这个点，相当于一个剪枝。 
        rest-=k;
        a[i].v-=k;
        a[i^1].v+=k;
      }
    return flow-rest;
}
void work()
{
    int flow;
    while (bfs())//每次建立新图。 
      while (flow=dinic(1,M)) ans+=flow;//寻找增广路。 
    return ;
}
int main()
{
    init();
    work();
    printf("%d",ans);
    return 0;
}

费用流

每条边给另一个值单位费用w（x，y）。
求在最大流前提下的最小费用和。

EK

EK算法求最大流的基础上，用spfa求一个费用最短路。

模板

#include<bits/stdc++.h>
using namespace std;
const int MM=1e9;
int n,m,s,t,tot=1,ansf,answ;
int q[200010]={},pre[5010]={},dis[5010]={},inf[200010]={};
bool vis[5010]={}; 
struct edge
{
    int y,next,v,w;
}a[100010];
int linkk[5010]={};
void insert(int x,int y,int v,int w)
{
    a[++tot].y=y;a[tot].v=v; a[tot].w=w;
    a[tot].next=linkk[x];  linkk[x]=tot;
    a[++tot].y=x;a[tot].v=0;a[tot].w=-w;
    a[tot].next=linkk[y];  linkk[y]=tot;
    return ;
}
void init()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);
    int x,y,v,w;
    for(int i=1;i<=m;++i)
      {
        scanf("%d%d%d%d",&x,&y,&v,&w);
        insert(x,y,v,w);
      }
    return ; 
}
bool spfa()
{
    memset(vis,0,sizeof(vis));
    memset(dis,10,sizeof(dis));
    q[1]=s;vis[s]=1;
    dis[s]=0;inf[s]=MM;
    int head=0,tail=1;
    while (++head<=tail)
      {
        int x=q[head];
        for(int i=linkk[x];i;i=a[i].next)
          {
            if (!a[i].v) continue;
            int y=a[i].y;
            if (dis[y]>dis[x]+a[i].w)
              {
                  dis[y]=dis[x]+a[i].w;
                  inf[y]=min(inf[x],a[i].v);
                  pre[y]=i;
                  if (!vis[y]) 
                    {
                        vis[y]=1;
                        q[++tail]=y;
                    }
              }
          }
          vis[x]=0;
      }
      return (dis[t]!=dis[n+1]);
}
void updata()
{
    int x=t;
    while (x!=s)
      {
        int i=pre[x];
        a[i].v-=inf[t];
        a[i^1].v+=inf[t];
        x=a[i^1].y;
      }
    ansf+=inf[t];
    answ+=dis[t]*inf[t];
}
int main()
{
    init();
    while (spfa())
      updata();
    printf("%d %d",ansf,answ);
    return 0;
}

最小割

在一张网络中，割掉若干条边，使网络不连通（源点无法到达汇点），而割掉边的所有方案中，边权值和最小的方案就是最小割。

性质

1.割>=最大流
就是说割的边容量之和是大于等于最大流的。
如果有小于等于最大流的割，那么说明网络中仍有增广路，而最大流满足网络中没有增广路，两者相矛盾
2.最小割=最大流
网络最大流量等于最小割的流量和。
根据性质1，方案最优的最小割是等于最大流的。

求最小割每条边

求出最大流之后，在剩余容量网络中跑bfs。标记可以到达的点。枚举边（x，y）。x被标记而y不被标记的边为割边。

点边转化

当要求割去点的时候，可以通过把点拆为·x,x’(x’即在x+n位置)，然后将x与x’连有向边x->x’。（容量为点权）
对于每条无向边，连两条有向边x’->y,y’->x。（容量为无穷大）
然后求最小割（最大流）。
求出答案。

模板

背景

FJ有个农场，其中有n块土地，由m条边连起来。FJ的养牛场在土地1，在土地n有个新开张的雪糕店。Bessie经常偷偷溜到雪糕店，当Bessie去的时候，FJ就要跟上她。但是Bessie很聪明，她在从雪糕店返回时不会经过去雪糕店时经过的农场，因此FJ总是抓不住Bessie。 为了防止Bessie生病，FJ决定把一些诚实的狗放在一些土地(1和n除外)上，使Bessie无法在满足每块土地最多只经过一次的条件的情况下，从养牛场溜到雪糕店然后又溜回养牛场。 求出FJ最少要放多少只狗。数据保证1和n间没有直接的连边。

解析

由于可以到达终点，但只能留一条路径，所以求了最小割以后减去1，就是答案，但不要忘了特判0。

code

#include<bits/stdc++.h>
using namespace std;
const int MM=2e9;
int n,m,s,t,tot=1,ans=0;
struct edge
{
    int y,next,v;
}a[100010];
int linkk[2010]={},inf[2010]={},pre[100010]={},q[1000010]={};
bool vis[2010]={};
void insert(int x,int y,int v)
{
    a[++tot].y=y;a[tot].next=linkk[x];
    linkk[x]=tot;a[tot].v=v;
    a[++tot].y=x;a[tot].next=linkk[y];
    linkk[y]=tot;a[tot].v=0;//反向边 
}
void init()
{
    scanf("%d%d",&n,&m);
    s=1+n;t=n;
    for(int i=2;i<n;++i)
      insert(i,i+n,1);//拆点 
    int x,y;
    for(int i=1;i<=m;++i)
      {
        scanf("%d%d",&x,&y);
        insert(x+n,y,MM);
        insert(y+n,x,MM);//连边 
      }
    return ;
}
bool bfs()
{
    memset(vis,0,sizeof(vis));
    int head=0,tail=1;
    q[1]=s;vis[s]=1;inf[s]=MM;
    while (++head<=tail)
      {
        int x=q[head];
        for(int i=linkk[x];i;i=a[i].next)
          if (a[i].v)
            {
                int y=a[i].y;
                if (vis[y]) continue;
                inf[y]=min(inf[x],a[i].v);
                pre[y]=i;
                vis[y]=1;q[++tail]=y;
                if (y==t) return 1;
            }
      }
    return 0;
}
void updata()
{
    int x=t;
    while (x!=s)
      {
        int i=pre[x];
        a[i].v-=inf[t];
        a[i^1].v+=inf[t];
        x=a[i^1].y;
      }
    ans+=inf[t];
}
void work()
{
    while (bfs())
      updata();
    if (!ans) printf("%d",ans);
    else printf("%d",ans-1);
    return ;
}
int main()
{
    init();
    work();
    return 0;
}