bzoj1001（对偶图最短路）

1001: [BeiJing2006]狼抓兔子

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

-----------------------------------------我是傲娇的分割线---------------------------------------------

显然是个最大流问题。

边数达到了10^6级别，显然用dinic算法会TLE

对于一个平面图来说，当然用对偶图的最短路来求最小割（最大流）

SPFA转移的时候注意判断边界情况

应该要开longlong才能过

上代码：

/**************************************************************
    Problem: 1001
    User: xialan
    Language: C++
    Result: Accepted
    Time:5648 ms
    Memory:56480 kb
****************************************************************/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<climits>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
typedef long long LL;
inline LL read(){
    LL x=;char ch=getchar();
    while(ch<''||ch>'')ch=getchar();
    while(ch>=''&&ch<=''){
        x=x*+ch-'';
        ch=getchar();
    }
    return x;
}
struct edge{
    int x,y;bool f;
};
queue<edge>q;
const int M=;
const LL MM=(LL)1e15;
LL dis[M][M][],hang[M][M],lie[M][M],xie[M][M],vis[M][M][];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    rep(i,,n)rep(j,,m-)hang[i][j]=read();
    rep(i,,n-)rep(j,,m)lie[i][j]=read();
    rep(i,,n-)rep(j,,m-)xie[i][j]=read();
    rep(i,,n-)rep(j,,m-)dis[i][j][]=dis[i][j][]=MM;
    memset(vis,,sizeof(vis));
    rep(i,,m-){
        dis[][i][]=hang[][i];
        vis[][i][]=;
        q.push((edge){,i,});
    }
    dis[][m-][]=min(hang[][m-],lie[][m]);
    q.push((edge){,m-,});
    vis[][m-][]=;
    rep(i,,n-){
        dis[i][m-][]=lie[i][m];
        vis[i][m-][]=;
        q.push((edge){i,m-,});
    }

    while(!q.empty()){
        edge u=q.front();q.pop();vis[u.x][u.y][u.f]=;
        if(u.f){
            if(u.x>){
                if(dis[u.x-][u.y][]>dis[u.x][u.y][]+hang[u.x][u.y]){
                    dis[u.x-][u.y][]=dis[u.x][u.y][]+hang[u.x][u.y];
                    if(!vis[u.x-][u.y][]){
                        vis[u.x-][u.y][]=;
                        q.push((edge){u.x-,u.y,});
                    }
                }
            }
            if(u.y<m-){
                if(dis[u.x][u.y+][]>dis[u.x][u.y][]+lie[u.x][u.y+]){
                    dis[u.x][u.y+][]=dis[u.x][u.y][]+lie[u.x][u.y+];
                    if(!vis[u.x][u.y+][]){
                        vis[u.x][u.y+][]=;
                        q.push((edge){u.x,u.y+,});
                    }
                }
            }
            if(dis[u.x][u.y][]>dis[u.x][u.y][]+xie[u.x][u.y]){
                dis[u.x][u.y][]=dis[u.x][u.y][]+xie[u.x][u.y];
                if(!vis[u.x][u.y][]){
                    vis[u.x][u.y][]=;
                    q.push((edge){u.x,u.y,});
                }
            }
        }
        else{
            if(u.x<n-){
                if(dis[u.x+][u.y][]>dis[u.x][u.y][]+hang[u.x+][u.y]){
                    dis[u.x+][u.y][]=dis[u.x][u.y][]+hang[u.x+][u.y];
                    if(!vis[u.x+][u.y][]){
                        vis[u.x+][u.y][]=;
                        q.push((edge){u.x+,u.y,});
                    }
                }
            }
            if(u.y>){
                if(dis[u.x][u.y-][]>dis[u.x][u.y][]+lie[u.x][u.y]){
                    dis[u.x][u.y-][]=dis[u.x][u.y][]+lie[u.x][u.y];
                    if(!vis[u.x][u.y-][]){
                        vis[u.x][u.y-][]=;
                        q.push((edge){u.x,u.y-,});
                    }
                }
            }
            if(dis[u.x][u.y][]>dis[u.x][u.y][]+xie[u.x][u.y]){
                dis[u.x][u.y][]=dis[u.x][u.y][]+xie[u.x][u.y];
                if(!vis[u.x][u.y][]){
                    vis[u.x][u.y][]=;
                    q.push((edge){u.x,u.y,});
                }
            }
        }
    }
    LL MIN=INT_MAX;
    rep(i,,n-)MIN=min(MIN,dis[i][][]+lie[i][]);
    rep(i,,m-)MIN=min(MIN,dis[n-][i][]+hang[n][i]);
    printf("%lld\n",MIN);
    return ;
}