HUNAN OJ 11567 Escaping

Problem description

One day, Large cruise ”Wu Kong” at sea. The station is represented by a square n*n divided into 1*1 blocks. Unfortunately , ” Wu Kong” hit an iceberg .It will sink after t minutes ,then every people die. However, there will be some life-saving equipment in some rooms(not only one), People from one room to reach another adjacent room (only four) needs one minute .If the people on board to get these life-saving devices so that they will survive, find the greatest number of people can survive.

Input

The first line contains two integers n and t (2 ≤ n ≤ 10, 1 ≤ t ≤ 10). Each of the next n lines contains n integers(0<=A[i][j]<=9).the people number at this time. Each of the next n more lines contains n integers, Indicates that the room have the number of life-saving equipment(0<=B[i][j]<=9).

Output

Print a single number — the maximum number of people who will be saved.

Sample Input

3 3

1 0 0

1 0 0

1 0 0

0 0 0

0 0 0

0 0 3

Sample Output

2

BFS预处理，然后建图跑最大流

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#include <queue>
#include <set>
#include <bitset>
#include <climits>

using namespace std;

const int INF = 0x3f3f3f3f;

const int MAXN = 200000;

const int MAXM = 400005;

int n, m, u, v, w;

struct point
{
int x, y, step;
friend bool operator < (const point& a, const point& b)
{
return a.step > b.step;
}
};

int mp[15][15], a, t, x[15][15];

int dirx[] = {1, -1, 0, 0};

int diry[] = {0, 0, 1, -1};

bool vis[15][15];

struct Edge
{
int to, next, flow;
} edge[MAXM];

int head[MAXN], tot;

void add(int u, int v, int w)
{
edge[tot].to = v;
edge[tot].flow = w;
edge[tot].next = head[u];
head[u] = tot++;

edge[tot].to = u;
edge[tot].flow = 0;
edge[tot].next = head[v];
head[v] = tot++;
}

int dep[MAXN];

bool bfs(int s, int t)
{
int u;
memset(dep, -1, sizeof(dep));
queue <int> q;
q.push(s);
dep[s] = 0;
while(!q.empty())
{
u = q.front();
q.pop();
for(int i = head[u]; ~i; i = edge[i].next)
{
int v = edge[i].to;
if(dep[v] == -1 && edge[i].flow > 0)
{
dep[v] = dep[u] + 1;
if(v == t)return true;
q.push(v);
}
}
}
return false;
}

int dfs(int s, int t, int x)
{
if(s == t)return x;
int ans = x;
for(int i = head[s]; ~i; i = edge[i].next)
{
int v = edge[i].to;
if(dep[v] == dep[s] + 1 && edge[i].flow > 0)
{
int minn = dfs(v, t, min(x, edge[i].flow));
edge[i].flow -= minn;
edge[i ^ 1].flow += minn;
x -= minn;
}
}
return ans - x;
}

int dinic()
{
int ans = 0;
while(bfs(1, n))ans += dfs(1, n, INF);
return ans;
}

bool judge(int x, int y)
{
return (x >= 0 && x < a && y >= 0 && y < a && !vis[x][y]);
}

void pre(point x)
{
priority_queue <point> q;
point F, N;
q.push(x);
int node = x.x * a + x.y + 2;
memset(vis, false, sizeof(vis));
while(!q.empty())
{
F = q.top();
q.pop();
if(F.step > t)break;
//cout<<mp[2][2]<<endl;
if(mp[F.x][F.y] >= 1)add(node, F.x * a + F.y + a * a + 2, INF);
for(int i = 0; i < 4; ++i)
{
N.x = F.x + dirx[i];
N.y = F.y + diry[i];
if(judge(N.x, N.y))
{
vis[N.x][N.y] = true;
N.step = F.step + 1;
q.push(N);
}
}
}
}

point Q;

int main()
{
//freopen("in.txt", "r", stdin);
while(scanf("%d%d", &a, &t) == 2)
{
tot = 0;
memset(head, -1, sizeof(head));
for(int i = 0; i < a; ++i)
{
for(int j = 0; j < a; ++j)scanf("%d", &x[i][j]);
}
n = 2 * a * a + 2;
for(int i = 0; i < a; ++i)
{
for(int j = 0; j < a; ++j)
{
scanf("%d", &mp[i][j]);
if(mp[i][j] >= 1)add(a * a + 2 + i * a + j, n, mp[i][j]);
}
}
for(int i = 0; i < a; ++i)
{
for(int j = 0; j < a; ++j)
{
if(x[i][j] >= 1)
{
add(1, i * a + j + 2, x[i][j]);
Q.step = 0;
Q.x = i;
Q.y = j;
pre(Q);
}
}
}
printf("%d\n", dinic());
}
return 0;
}