网络流

网络流是一个很奇怪的东西...

概念：

V表示整个图中的所有结点的集合.
E表示整个图中所有边的集合.
G = (V,E) ,表示整个有向图.
s表示网络的源点, t表示网络的汇点.
对于每条边(u,v),有一个容量c(u,v) (c(u,v)>=0)
如果c(u,v)=0，则表示(u,v)不在网络中。
如果原网络中不存在边(u,v)，则令c(u,v)=0
对于每条边(u,v),有一个流量f(u,v).

 

网络流三个性质
容量限制：f(u,v) <= c(u,v)
对称性：f(u,v) == -f(v,u)
收支平衡: 对于不是源点也不是汇点的任意结点,流入该结点的流量和等于流出该结点的流量和。

只要满足这三个性质,就是一个合法的网络流.

网络的流量、最大流
一个合法的网络流量|f|定义为：
从源点流出的流量 ∑f(s,v)
流向汇点的流量 ∑f(v,t)

|f|的最大值表示为最大流

残量网络：

对于网络中的每一条边，计算容量与流量的差即表示为残量。

R(u,v) = C(u,v) – F(u,v)

形象的说，一条边的残量即为该边还能流过的流量。

在寻找最大流的过程中，有些弧的选择一开始可能就是错误的。
所以在路径中加上后向弧，作为标记。
当发现了另一条可增广的路径是并包含后向弧，意味这条路径对以前对这条弧顶选择进行取消
后向弧为算法纠正自己所犯的错误提供了可能性，它允许算法取消先前的错误的行为

后向弧的建立就让我们的贪心有了后悔的余地！

Dinic算法

Dinic算法的基本思路:
1.根据残量网络计算层次图。
2.在层次图中使用DFS进行增广直到不存在增广路
3.重复以上步骤直到无法增广
时间复杂度为O(N^2*M)
实际上，理论数值所对应的数据几乎不会出现，通常并不会想理论值说的这么慢，只会更快。

上图为BFS出当前图的层次图，然后利用DFS实现多路增广，所谓多路增广，对于上图有两条增广路。DFS可以一次实现。

上图为BFS出当前图的层次图，然后利用DFS实现多路增广，所谓多路增广，对于上图有两条增广路。DFS可以一次实现。

01. 搭配飞行员 [网络流24题]
«问题描述：
第二次世界大战时期，英国皇家空军从沦陷国征募了大量外籍飞行员。由皇家空军派出的每一架飞机都需要配备在航行技能和语言上能互相配合的2 名飞行员，其中1 名是英国飞行员，另1 名是外籍飞行员。在众多的飞行员中，每一名外籍飞行员都可以与其他若干名英国飞行员很好地配合。如何选择配对飞行的飞行员才能使一次派出最多的飞机。对于给定的外籍飞行员与英国飞行员的配合情况，试设计一个算法找出最佳飞行员配对方案，使皇家空军一次能派出最多的飞机。
«编程任务：
对于给定的外籍飞行员与英国飞行员的配合情况，编程找出一个最佳飞行员配对方案，使皇家空军一次能派出最多的飞机。
«结果输出:
程序运行结束时，将最佳飞行员配对方案输出到文件output.txt 中。第1 行是最佳飞行员配对方案一次能派出的最多的飞机数M。

«算法解析：
首先这是一道裸的二分图题。
那么用最大流解决。
建模方法：
1.设置一个超级源点S，设置一个超级汇点T。
2.从S向每个外籍飞行员连一条边，容量为1。
3.从每个皇家飞行员向T连一条边，容量为1。
4.根据输入，从每个外籍飞行员向皇家飞行员 连一条容量为1的边。
对该网络求从S到T的最大流

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
#define N 205
#define ms(a,b) memset(a,b,sizeof(a))
int n,m;
struct node
{
    int next,to,flow;
}e[25*N];
int dep[N];
int head[N],cnt,map[N][N],fa[N];
void init()
{
    ms(dep,-1);
    ms(head,-1);
    ms(fa,-1);
}
void update(int x,int c)
{
    e[x].flow-=c;
    e[x^1].flow+=c;
}
void add(int x,int y,int z)
{
    e[cnt].next=head[x];
    e[cnt].to=y;
    e[cnt].flow=z;
    head[x]=cnt++;
}
int bfs()
{
    ms(dep,-1);
    queue <int>q;
    q.push(0);
    dep[0]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x];i!=-1;i=e[i].next)
        {
            int to1=e[i].to;
            if(e[i].flow!=0&&dep[to1]==-1)
            {
                q.push(to1);
                dep[to1]=dep[x]+1;
            }
        }
    }
    return dep[n+1]==-1?0:1;
}
int dfs(int p,int maxflow)
{
    if(p==n+1)
    {
        return maxflow;
    }
    int tflow=maxflow,nowflow;
    for(int i=head[p];i!=-1;i=e[i].next)
    {
        int to1=e[i].to;
        if(dep[to1]==dep[p]+1&&e[i].flow!=0)
        {
            nowflow=dfs(to1,maxflow);
            tflow-=nowflow;
            update(i,nowflow);
            if(tflow==0)break;
        } 
    }
    return maxflow-tflow;
}
int main()
{
    scanf("%d%d",&m,&n);
    init();
    while(1)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(x==y&&x==-1) break;
        add(y,x,1);
        add(x,y,0); 
    }
    for(int i=m+1;i<=n;i++)
    {
        add(0,i,1);
        add(i,0,0);
    }
    for(int i=1;i<=m;i++)
    {
        add(n+1,i,0);
        add(i,n+1,1);
    }
    int ans=0;
    while(bfs()!=0)
    {
        ans+=dfs(0,1);
    }
    if(ans!=0)
    {
        printf("%d
",ans);
        for(int i=1;i<=m;i++)
        {
            for(int j=head[i];j!=-1;j=e[j].next)
            {
                if(e[j].flow==1&&e[j].to!=n+1)
                {
                    printf("%d %d
",i,e[j].to);
                }
            }
        } 
    }else
    {
        printf("No Solution!
");
    }
}

...今天先到这里吧...