bzoj1001 [BeiJing2006]狼抓兔子

(color{#0066ff}{ 题目描述 })

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

左上角点为(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只狼，
才能完全封锁这条道路，你需要帮助狼王安排一个伏击方案，使得在将兔子一网打尽的前提下，参与的
狼的数量要最小。因为狼还要去找喜羊羊麻烦.

$color{#0066ff}{ 输入格式 } $

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

(color{#0066ff}{输出格式})

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

(color{#0066ff}{输入样例})

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

(color{#0066ff}{输出样例})

14

(color{#0066ff}{数据范围与提示})

none

(color{#0066ff}{ 题解 })

显然要求一个最小割。。。

于是连上边跑一边最大流最小割即可

连边发现，是双向边，直接连，不用建反向边，因为连的就是双向的

#include<bits/stdc++.h>
#define LL long long
LL in() {
	char ch; LL x = 0, f = 1;
	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
	return x * f;
}
const int maxn = 1001;
struct node {
	int to, dis;
	node *nxt, *rev;
	node(int to = 0, int dis = 0, node *nxt  = NULL): to(to), dis(dis), nxt(nxt) {}
	void *operator new(size_t) {
		static node *S = NULL, *T = NULL;
		return (S == T) && (T = (S = new node[1024]) + 1024), S++;
	}
}*head[maxn * maxn], *cur[maxn * maxn];
int dep[maxn * maxn];
int id[maxn][maxn];
void add(int from, int to, int dis) {
	head[from] = new node(to, dis, head[from]);
}
void link(int from, int to, int dis) {
	add(from, to, dis);
	add(to, from, dis);
	head[from]->rev = head[to];
	head[to]->rev = head[from];
}
int s, t;
bool bfs() {
	for(int i = s; i <= t; i++) cur[i] = head[i], dep[i] = 0;
	std::queue<int> q;
	q.push(s);
	dep[s] = 1;
	while(!q.empty()) {
		int tp = q.front(); q.pop();
		for(node *i = head[tp]; i; i = i->nxt) 
			if(!dep[i->to] && i->dis)
				dep[i->to] = dep[tp] + 1, q.push(i->to);
	}
	return dep[t];
}
int dfs(int x, int change) {
	if(x == t || !change) return change;
	int flow = 0, ls;
	for(node *i = cur[x]; i; i = i->nxt) {
		cur[x] = i;
		if(dep[i->to] == dep[x] + 1 && (ls = dfs(i->to, std::min(change, i->dis)))) {
			flow += ls;
			change -= ls;
			i->dis -= ls;
			i->rev->dis += ls;
			if(!change) break;
		}
	}
	if(!flow) dep[x] = 0;
	return flow;
}
int n, m;
int dinic() {
	int flow = 0;
	while(bfs()) flow += dfs(s, 0x7fffffff);
	return flow;
}
int main() {
	n = in(), m = in();
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++) 
			id[i][j] = (i - 1) * m + j;
	s = 1, t = id[n][m];
	int v;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j < m; j++) {
			v = in();
			link(id[i][j], id[i][j + 1], v);
		}
	for(int i = 1; i < n; i++)
		for(int j = 1; j <= m; j++) {
			v = in();
			link(id[i][j], id[i + 1][j], v);
		}
	for(int i = 1; i < n; i++)
		for(int j = 1; j < m; j++) {
			v = in();
			link(id[i][j], id[i + 1][j + 1], v);
		}
	printf("%d
", dinic());
	return 0;
}