BZOJ1412 [ZJOI2009]狼和羊的故事 【最小割】

1412: [ZJOI2009]狼和羊的故事

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 3454  Solved: 1733
[Submit][Status][Discuss]

Description

“狼爱上羊啊爱的疯狂，谁让他们真爱了一场；狼爱上羊啊并不荒唐，他们说有爱就有方向．．．．．．” Orez听到这首歌，心想：狼和羊如此和谐，为什么不尝试羊狼合养呢？说干就干！ Orez的羊狼圈可以看作一个n*m个矩阵格子，这个矩阵的边缘已经装上了篱笆。可是Drake很快发现狼再怎么也是狼，它们总是对羊垂涎三尺，那首歌只不过是一个动人的传说而已。所以Orez决定在羊狼圈中再加入一些篱笆，还是要将羊狼分开来养。 通过仔细观察，Orez发现狼和羊都有属于自己领地，若狼和羊们不能呆在自己的领地，那它们就会变得非常暴躁，不利于他们的成长。 Orez想要添加篱笆的尽可能的短。当然这个篱笆首先得保证不能改变狼羊的所属领地，再就是篱笆必须修筑完整，也就是说必须修建在单位格子的边界上并且不能只修建一部分。

Input

文件的第一行包含两个整数n和m。接下来n行每行m个整数，1表示该格子属于狼的领地，2表示属于羊的领地，0表示该格子不是任何一只动物的领地。

Output

文件中仅包含一个整数ans，代表篱笆的最短长度。

Sample Input

2 2
2 2
1 1

Sample Output

2

数据范围
10%的数据 n，m≤3
30%的数据 n，m≤20
100%的数据 n，m≤100

为何狼羊与最小割总是联系到一块？

因为它们总是要被分割开【分割开，割开，开】

把矩阵每个单元看做一个点，向四周单元引一条容量为1的边【每建一个围栏代价为1】

如果属于羊，由S引一条容量为INF的边

如果属于狼，向T引一条容量为INF的边

这样最小割的边一定不是S和T相关的，而狼属于T，羊属于S，最小割算法就可以用最小的代价把它们分割开

其实想到最小割就很容易想到了

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define LL long long int
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define Redge(u) for (int k = head[u]; k != -1; k = edge[k].next)
using namespace std;
const int maxn = 10005,maxm = 100005,maxv = 105,INF = 1000000000;
inline int RD(){
	int out = 0,flag = 1; char c = getchar();
	while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
	while (c >= 48 && c <= 57) {out = (out << 1) + (out << 3) + c - '0'; c = getchar();}
	return out * flag;
}
int n,m,S,T,d[maxn],X[4] = {0,0,-1,1},Y[4] = {1,-1,0,0},q[maxn],cur[maxn];
bool vis[maxn];
int head[maxn],nedge = 0;
struct EDGE{int to,f,next;}edge[maxm];
inline void build(int u,int v,int w){
	edge[nedge] = (EDGE){v,w,head[u]}; head[u] = nedge++;
	edge[nedge] = (EDGE){u,0,head[v]}; head[v] = nedge++;
}
bool bfs(){
	for (int i = 0; i <= T; i++) vis[i] = false;
	int u,h = 0,t = 0,to;
	d[S] = 0; vis[S] = true; q[++t] = S;
	while (h < t){
		u = q[++h];
		Redge(u) if (edge[k].f && !vis[to = edge[k].to]){
			d[to] = d[u] + 1; vis[to] = true; q[++t] = to;
		}
	}
	return vis[T];
}
int dfs(int u,int minf){
	if (u == T || !minf) return minf;
	int flow = 0,f,to;
	if (cur[u] == -2) cur[u] = head[u];
	for (int& k = cur[u]; k != -1; k = edge[k].next)
		if (d[to = edge[k].to] == d[u] + 1 && (f = dfs(to,min(minf,edge[k].f)))){
			edge[k].f -= f;
			edge[k ^ 1].f += f;
			flow += f;
			minf -= f;
			if (!minf) break;
		}
	return flow;
}
int maxflow(){
	int flow = 0;
	while (bfs()){
		fill(cur,cur + maxn,-2);
		flow += dfs(S,INF);
	}
	return flow;
}
inline int id(int x,int y){return m * (x - 1) + y;}
int main(){
	memset(head,-1,sizeof(head));
	n = RD(); m = RD(); S = 0; T = n * m + 1; int u,x,y;
	REP(i,n) REP(j,m){
		u = id(i,j);
		for (int k = 0; k < 4; k++){
			x = i + X[k]; y = j + Y[k];
			if (x && y && x <= n && y <= m) build(u,id(x,y),1);
		}
		x = RD();
		if (x == 1) build(S,u,INF);
		else if (x == 2) build(u,T,INF);
	}
	cout<<maxflow()<<endl;
	return 0;
}