最大流

概念

网络流用于解决流量问题

定义

定义：带权的有向图G=（V，E）满足以下条件，则称为网络流图
1.仅有一个入度为0的顶点s,s称为源点
2.仅有一个出度为0的顶点t,t称为汇点
3.每条边的权值都为非负数，称为该边的容量，记为c(i,j)
弧的流量： 实际流量f(u,v)

性质

把f(x,y)称为流量，则称f为流函数，满足三个性质：
1.容量限制：每条边的流量不能超过该边的流量
2.斜对称：正向边的流量等于反向边的流量
3.流量守恒：正向所有流量和等于所有反向流量和

最大流

对于网络流图G，流量最大的可行流f，称为最大流

问题

裸题：n个点m条边组成的有向图，每个节点代表一个水管节点，每条边代表一条管道。每条边有一个边权代表这条边的水容量。求s到t的最大水流量

最大流最小割定理

是指在一个网络流中，能够从源点到达汇点的最大流量等于如果从网络中移除就能够导致网络流中断的边的集合的最小容量和。即在任何网络中，最大流的值等于最小割的容量。

增广路径

流量未满，未能到达容量上限的路径

残量网络

残量网络：在任意时刻，网络中所有节点以及剩余容量大于0的边构成的子图称为残量网络

反向边

引入反向边的概念，即每一条边(v,u)都有一条反向边（u,v）。作用：一条路径可能包含多条增广路径，为了寻找多条增广路径，我们让这一条边有多条被选择的机会。

分层图

分层图：根绝BFS宽度优先搜索，我们知道对于x节点，我们用d[x]表示它的层次，即s到t最少需要经过的边数。在残量网络中，满足d[y]=d[x]+1的边（x,y）构成的子图称为分层图，而分层图是一个有像无环图。

做法

1.用BFS构造出分层图
d[1]=1,d[2]=2,d[3]=2(它是1和2的前驱，取最小),d[4]=3,d[5]=3.
2.DFS在分层图上寻找增广路直至不存在增广路
这样做只需要根绝深度进行计算即可。比如1->2->4->5,是不满足题意的因为d[4]==d[5]。但是1->3->5是可以的。经过计算，最终3->5为0(可以当作无边)。
3.重复以上操作直至无法增广
重新进行分层图。d[1]=1,d[2]=2,d[3]=2,d[4]=3,d[5]=4,再计算…

优化

当前弧优化

我们在按照dfs顺序时，先被遍历过得边已经增广过了，那么这条边会被视为“费边”。下次到达该节点时，直接无视费边。

多路增广

当我们dfs可以找到一条增广路时不直接返回，而是改变used的值，如果used没有到达流量上限，就继续寻找下一条增广路
这里是引用

炸点

模板题

模板题

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <queue>
#define inf 0x3f3f3f3f
using namespace std;
const int N=6e4+5;
struct node
{
    int v,cap,to;
}s[N];
int cnt,head[N],dis[N];
int a,t;///»ãµã
void add(int u,int v,int cap)
{
    s[cnt].v=v;
    s[cnt].cap=cap;
    s[cnt].to=head[u];
    head[u]=cnt++;
    s[cnt].v=u;
    s[cnt].cap=0;
    s[cnt].to=head[v];
    head[v]=cnt++;
}
bool bfs()
{
    queue<int>q;
    memset(dis,0,sizeof(dis));
    dis[a]=1;
    q.push(a);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int e=head[u];~e;e=s[e].to)
        {
            int v=s[e].v,cap=s[e].cap;
            if(!dis[v]&&cap>0)
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return dis[t]!=0;
}
int dfs(int u,int flow)
{
    int mm;
    if(u==t)
        return flow;
    for(int e=head[u];~e;e=s[e].to)
    {
        int v=s[e].v,cap=s[e].cap;
        if(cap>0&&dis[v]==dis[u]+1&&(mm=dfs(v,min(cap,flow))))
        {
            s[e].cap-=mm;
            s[e^1].cap+=mm;
            return mm;
        }
    }
    dis[u]=-1;
    return 0;
}
int dinic()
{
    int ans=0,tf;
    while(bfs())
    {
        while(tf=dfs(a,inf))//0±íʾԴµã
        {
            //printf("%d*\n",tf);
            ans+=tf;
        }
    }
    return ans;
}
void init()///³õʼ»¯
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
int main()
{
    init();
    printf("%d\n",dinic());
    return 0;
}