BZOJ1001——网络流的最大流和最小割定理

定理：

　　在网络中，如果f是一个流，CUT (S,T)是一个割，且f的值等于割CUT(S,T)的容量，那么f是一个最大流， CUT(S,T)是一个最小割。

证明：

　　令割CUT（S,T）的容量为C，所以流f的流量也为C。假设另外的任意流f1，流量为c1，根据流量不超过割的容量，则c1<=c,所以f是最大流。 假设另外的任意割CUT（S1,T1），容量为c1，根据流量不超过割的容量，所以有c1>=c,故，CUT（S,T）是最小割[2] 。

也就是说，在一个网络流图中，最大流等于最小割。

什么是最小割？点这里有详细的论述

按照我本人的理解，大概可以这么描述：即把一张图分成两个点集U和V，其中源点ST∈U，汇点EN∈V，则所有从点集U连向点集V的变得权值之和的最小值称为该图的最小割。

---

---

Description

现在小朋友们最喜欢的”喜羊羊与灰太狼”,话说灰太狼抓羊不到，但抓兔子还是比较在行的，
而且现在的兔子还比较笨，它们只有两个窝，现在你做为狼王，面对下面这样一个网格的地形：

左上角点为(1,1),右下角点为(N,M)(上图中N=3,M=4).有以下三种类型的道路
1:(x,y)<==>(x+1,y)
2:(x,y)<==>(x,y+1)
3:(x,y)<==>(x+1,y+1)
道路上的权值表示这条路上最多能够通过的兔子数，道路是无向的. 左上角和右下角为兔子的两个窝，
开始时所有的兔子都聚集在左上角(1,1)的窝里，现在它们要跑到右下解(N,M)的窝中去，狼王开始伏击
这些兔子.当然为了保险起见，如果一条道路上最多通过的兔子数为K，狼王需要安排同样数量的K只狼，
才能完全封锁这条道路，你需要帮助狼王安排一个伏击方案，使得在将兔子一网打尽的前提下，参与的
狼的数量要最小。因为狼还要去找喜羊羊麻烦.
Input

第一行为N,M.表示网格的大小，N,M均小于等于1000.
接下来分三部分
第一部分共N行，每行M-1个数，表示横向道路的权值.
第二部分共N-1行，每行M个数，表示纵向道路的权值.
第三部分共N-1行，每行M-1个数，表示斜向道路的权值.
输入文件保证不超过10M
Output

输出一个整数，表示参与伏击的狼的最小数量.

Sample Input

3 4

5 6 4

4 3 1

7 5 3

5 6 7 8

8 7 6 5

5 5 5

6 6 6
Sample Output

14

---

---

只要我们找到两个点集U和V，一个包含ST(源点)，一个包含EN(汇点)，那么这两个点集之间的边之和即为所需要的狼数。因此显而易见，本道题只要求出该图的最小割即可。

利用最大流的最小割定理，我们知道求一张图的最小割只要求最大流即可，所以我们求出最大流，即为答案。

怎么求最大流？点这里，我写的挺详细的

本题要建双向边，跑Dinic，EK会超时。

注意在DFS时要加”if(!res)dist[now]=0;”这句话，不然会超时。

这句话因为下次DFSnow这个点时得到的最小流量为0，所以就没必要DFS下去，一个剪枝。

#include<bits/stdc++.h>
using namespace std;

char tc()
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}

int read()
{
    char c;while(c=tc(),(c<'0'||c>'9')&&c!='-');
    int x=0,y=1;c=='-'?y=-1:x=c-'0';
    while(c=tc(),c>='0'&&c<='9')x=x*10+c-'0';
    return x*y;
}

const int MAXN=1000005,MAXM=6000005;

struct node{
    int to,val;
}L[MAXM];
int cnt=0,nxt[MAXM],head[MAXN],q[MAXM],dis[MAXN],h,t,ST,EN;
int n,m,ans;

void add(int x,int y,int fx,int fy,int c){
    int u=(x-1)*m+y,v=(fx-1)*m+fy;
    L[cnt]=(node){v,c};
    nxt[cnt]=head[u];
    head[u]=cnt;
    cnt++;
}

int BFS(){
    memset(dis,0,sizeof(dis));
    h=0;t=1;q[t]=ST;dis[ST]=1;
    while(h<t){
        int front=q[++h];
        for(int i=head[front];i!=-1;i=nxt[i]){
            int to=L[i].to;
            if(!dis[to]&&L[i].val){
                dis[to]=dis[front]+1;
                q[++t]=to;
            }
        }
    }
    return dis[EN];
}

int DFS(int now,int x){
    if(now==EN) return x;
    int res=0;
    for(int i=head[now];i!=-1&&x;i=nxt[i]){
        int to=L[i].to;
        if(dis[to]==dis[now]+1&&L[i].val){
            int fd=DFS(to,min(x,L[i].val));
            x-=fd;L[i].val-=fd;
            L[i^1].val+=fd;res+=fd;
        }
    }
    if(!res) dis[now]=0;
    return res;
}

int main()
{
    n=read();m=read();
    memset(head,-1,sizeof(head));
    register int i,j;
    int c;
    for(i=1;i<=n;i++)for(j=1;j<m;j++)c=read(),add(i,j,i,j+1,c),add(i,j+1,i,j,c);
    for(i=1;i<n;i++)for(j=1;j<=m;j++)c=read(),add(i,j,i+1,j,c),add(i+1,j,i,j,c);
    for(i=1;i<n;i++)for(j=1;j<m;j++)c=read(),add(i,j,i+1,j+1,c),add(i+1,j+1,i,j,c); 
    ST=1,EN=n*m;
    while(BFS()){
        ans+=DFS(ST,2e9);
    }
    printf("%d",ans);
    return 0;
}