BZOJ 1001[BeiJing2006]狼抓兔子 (网络流 Dinic)

1001: [BeiJing2006]狼抓兔子

Time Limit: 15 Sec  Memory Limit: 162 MB
Submit: 24061  Solved: 6086
[Submit][Status][Discuss]

Description

现在小朋友们最喜欢的"喜羊羊与灰太狼",话说灰太狼抓羊不到，但抓兔子还是比较在行的，

而且现在的兔子还比较笨，它们只有两个窝，现在你做为狼王，面对下面这样一个网格的地形：

 

左上角点为(1,1),右下角点为(N,M)(上图中N=4,M=5).有以下三种类型的道路 

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

Dinic 网络流;

套模板, 此模板 已经优化过了, 所以不会超时;

源点 start  汇点 END

代码:

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <list>
#include <map>
#include <set>
#include <bitset>
#include <vector>
#define mem(a,b) memset(a,b,sizeof(a))
#define findx(x) lower_bound(b+1,b+1+bn,x)-b
#define FIN      freopen("input.txt","r",stdin)
#define FOUT     freopen("output.txt","w",stdout)
#define S1(n)    scanf("%d",&n)
#define SL1(n)   scanf("%I64d",&n)
#define S2(n,m)  scanf("%d%d",&n,&m)
#define SL2(n,m)  scanf("%I64d%I64d",&n,&m)
#define Pr(n)     printf("%d\n",n)

using namespace std;
typedef long long ll;

const int INF=0x3f3f3f3f;
const double esp=1e-6;
const int maxn=1e6+5;
const int MOD=1e9+7;
const int mod=1e9+7;
int dir[5][2]={0,1,0,-1,1,0,-1,0};


struct node{
    int v,w,next; //u  v 从 u-v 权值为w
}edge[8*maxn];

int head[maxn],num[maxn],start,END,cnt,sum;
int n,m;
void init()
{
    cnt=0;
    mem(head,-1);
}
void add(int u,int v,int w)
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    /*edge[cnt].v=u;
    edge[cnt].w=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;
    */
}
int bfs()
{
    queue<int>Q;
    mem(num,0);
    num[start]=1;
    Q.push(start);
    while(!Q.empty())
    {
        int t=Q.front();
        Q.pop();
        if(t==END)
            return 1;
        for(int i=head[t];i!=-1;i=edge[i].next)// 链式前向星访问找增广路
        {
            int t1= edge[i].v;//下一个节点
            int t2= edge[i].w;// 当前点 权值
            if(t2&&num[t1]==0)// 当前点存在 并且下一个点没有访问
            {
                num[t1]=num[t]+1;// 点=1
                if(t1==END)//  结束
                    return 1;
                Q.push(t1);
            }
        }
    }
    return 0;
}
int dfs(int u,int maxflow)
{
    if(u==END)
        return maxflow;
    int res=0;

    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int t1=edge[i].v;// 下一个节点
        int t2=edge[i].w;// 当前节点
        if(t2&&num[t1]==num[u]+1)
        {
            int temp=dfs(t1,min(maxflow-res,t2));// 选择流 小的一部分

            edge[i].w-=temp;// 正向减少
            edge[i^1].w+=temp;//反向增加
            res+=temp;
            if(maxflow==res)
                return res;
        }
    }
    if(!res)
        num[u]=-1;
    return res;
}

void Dinic()
{
    int ans=0;
    while(bfs())
    {
        ans+=dfs(start,INF);
    }
    cout<<ans<<endl;
}

int main()
{
    while(~S2(n,m))
    {
        init();
        int x,y;
        int cost;
        start=1;
        END=n*m;
        for(int i=0;i<n;i++)// 横
            for(int j=1;j<=m-1;j++)
            {
                S1(cost);
                x= i*m+j;
                y= x+1;
                add(x,y,cost);
                add(y,x,cost);
            }
        for(int i=0;i<n-1;i++)//列
            for(int j=1;j<=m;j++)
            {
                S1(cost);
                x= i*m+j;
                y= x+m;
                add(x,y,cost);
                add(y,x,cost);
            }
        for(int i=0;i<n-1;i++)// 斜
            for(int j=1;j<=m-1;j++)
            {
                S1(cost);
                x= i*m+j;
                y= x+m+1;
                add(x,y,cost);
                add(y,x,cost);
            }
        Dinic();
    }
    return 0;
}
/*
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
*/

123