BZOJ 1066: [SCOI2007]蜥蜴 网络最大流

Description

　　在一个r行c列的网格地图中有一些高度不同的石柱，一些石柱上站着一些蜥蜴，你的任务是让尽量多的蜥蜴逃

到边界外。 每行每列中相邻石柱的距离为1，蜥蜴的跳跃距离是d，即蜥蜴可以跳到平面距离不超过d的任何一个石

柱上。石柱都不稳定，每次当蜥蜴跳跃时，所离开的石柱高度减1（如果仍然落在地图内部，则到达的石柱高度不

变），如果该石柱原来高度为1，则蜥蜴离开后消失。以后其他蜥蜴不能落脚。任何时刻不能有两只蜥蜴在同一个

石柱上。

Input

　　输入第一行为三个整数r，c，d，即地图的规模与最大跳跃距离。以下r行为石竹的初始状态，0表示没有石柱

，1~3表示石柱的初始高度。以下r行为蜥蜴位置，“L”表示蜥蜴，“.”表示没有蜥蜴。

Output

　　输出仅一行，包含一个整数，即无法逃离的蜥蜴总数的最小值。

Sample Input

5 8 2

00000000

02000000

00321100

02000000

00000000

……..

……..

..LLLL..

……..

……..

Sample Output

1

HINT

100%的数据满足：1<=r, c<=20, 1<=d<=4

解题方法： 题目要求无法逃离的蜥蜴的最小值，即求可以逃离的蜥蜴的最大值。选择使用最大流，当然重点在构图。

对于每一个石柱，我们可以拆成两个点，分别为入点和出点。

对于所有石柱，从入点到出点连边，容量为高度。这里等于限制了每一个石柱的跳跃次数。

对于最初有蜥蜴的石柱，从源点向这些点的入点连边，容量为1。因为每一个石柱只有一个蜥蜴。

对于任意一对可以相互到达的石柱，分别从彼此的出点到入点连边，容量为正无穷。等于假设可以有尽可能多的蜥蜴跳过。

对于可以跳到边界外的石柱，从出点向汇点连边，容量为正无穷。原理同上。 然后最后答案就是蜥蜴的个数减去 最大流。。(我才不会说把汇点和邻接表计数变量都写成T调试一天的SB是谁呢)

复杂度： O(Dinic)

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 400010;
const int maxm = 1000010;
#define rep(i, a, b) for(int i = a; i <= b; i++)
struct G
{
int v, cap, next;
G() {}
G(int v, int cap, int next) : v(v), cap(cap), next(next) {}
} E[maxm];
int p[maxn], T;
int d[maxn], temp_p[maxn], qw[maxn]; //d顶点到源点的距离标号,temp_p当前狐优化，qw队列
void init()
{
memset(p, -1, sizeof(p));
T = 0;
}
void add(int u, int v, int cap)
{
E[T] = G(v, cap, p[u]);
p[u] = T++;
E[T] = G(u, 0, p[v]);
p[v] = T++;
}
bool bfs(int st, int en, int n)
{
int i, u, v, head, tail;
for(i = 0; i <= n; i++) d[i] = -1;
head = tail = 0;
d[st] = 0;
qw[tail] = st;
while(head <= tail)
{
u = qw[head++];
for(i = p[u]; i + 1; i = E[i].next)
{
v = E[i].v;
if(d[v] == -1 && E[i].cap > 0)
{
d[v] = d[u] + 1;
qw[++tail] = v;
}
}
}
return (d[en] != -1);
}
int dfs(int u, int en, int f)
{
if(u == en || f == 0) return f;
int flow = 0, temp;
for(; temp_p[u] + 1; temp_p[u] = E[temp_p[u]].next)
{
G& e = E[temp_p[u]];
if(d[u] + 1 == d[e.v])
{
temp = dfs(e.v, en, min(f, e.cap));
if(temp > 0)
{
e.cap -= temp;
E[temp_p[u] ^ 1].cap += temp;
flow += temp;
f -= temp;
if(f == 0)  break;
}
}
}
return flow;
}
int dinic(int st, int en, int n)
{
int i, ans = 0;
while(bfs(st, en, n))
{
for(i = 0; i <= n; i++) temp_p[i] = p[i];
ans += dfs(st, en, INF);
}
return ans;
}
int st, en, n, m, dd, stone[220][220];
bool escape(int x, int y){
if(x <= dd || y <= dd || x > n - dd || y > m - dd) return true;
else return false;
}
bool check(int x1, int y1, int x2, int y2){
int x = (x1 - x2);
int y = (y1 - y2);
return (x * x + y * y) <= dd * dd;
}
int num(int x, int y){ //点标号
return (x - 1) * m + y;
}
int main(){
cin >> n >> m >> dd;
st = 0; en = 80001;
init();
int ans2 = 0;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
char ch;
cin >> ch;
if(escape(i, j)) add(n * m + num(i, j), en, INF);
if(ch == '0') continue;
stone[i][j] = (int)(ch - '0');
}
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
char ch;
cin >> ch;
if(ch == 'L'){
add(st, num(i, j), 1);
ans2++;
}
}
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
if(stone[i][j]) add(num(i, j), n * m + num(i, j), stone[i][j]);
for(int k = 1; k <= n; k++){
for(int l = 1; l <= m; l++){
if(!stone[k][l] || (k == i && l == j)) continue;
if(!check(i, j, k, l)) continue;
add(n * m + num(i, j), num(k, l), INF);
}
}
}
}
int ans = dinic(st, en, en );
//    printf("%d\n", ans2);
//    printf("%d\n", ans);
printf("%d\n", ans2 - ans);
return 0;
}