#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 15;
const int maxm = 1e6 + 15;
const int inf = 0x3f3f3f3f;
const int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int n, t, sx, sy;
char g[15][15];
int scientist[15][15], capsule[15][15];
int block[15][15], dis[15][15], kyori[15][15];
namespace dinic {
struct Edge {
  int to, cap, next;
};
int ecnt, s, t, N, F, D;
Edge es[maxn * 10];
int cur[maxn], dep[maxn], head[maxn];
void init() {
  memset(head, -1, sizeof head);
  ecnt = 0;
}
void add_edge(int u, int v, int cap) {
  es[ecnt].to = v;
  es[ecnt].next = head[u];
  es[ecnt].cap = cap;
  head[u] = ecnt++;
}
void add_double(int u, int v, int w1, int w2 = 0) {
  add_edge(u, v, w1);
  add_edge(v, u, w2);
}
bool BFS() {
  queue<int> q;
  q.push(s);
  memset(dep, 0x3f, sizeof dep);
  dep[s] = 0;
  while (q.size() && dep[t] == inf) {
    int u = q.front();
    q.pop();
    for (int i = head[u]; ~i; i = es[i].next) {
      Edge& e = es[i];
      if (e.cap > 0 && dep[e.to] == inf) {
        dep[e.to] = dep[u] + 1;
        q.push(e.to);
      }
    }
  }
  return dep[t] < inf;
}
int DFS(int u, int maxflow) {
  if (u == t) return maxflow;
  int res = 0;
  for (int i = cur[u]; ~i; i = es[i].next) {
    Edge& e = es[i];
    if (dep[e.to] == dep[u] + 1 && e.cap > 0) {
      int flow = DFS(e.to, min(maxflow, e.cap));
      cur[u] = i;
      res += flow;
      maxflow -= flow;
      es[i].cap -= flow;
      es[i ^ 1].cap += flow;
      if (!maxflow) return res;
    }
  }
  dep[u] = inf;
  return res;
}
int MaxFlow() {
  int ans = 0;
  while (BFS()) {
    for (int i = s; i <= t; i++) cur[i] = head[i];
    ans += DFS(s, inf);
  }
  return ans;
}
}  // namespace dinic
inline int getIndex(int x, int y) { return (x - 1) * n + y; }
int main() {
  scanf("%d %d", &n, &t);
  vector<pair<int, int> > person;
  for (int i = 1; i <= n; i++) {
    scanf("%s", g[i] + 1);
    for (int j = 1; j <= n; j++) {
      if (g[i][j] == 'Z') sx = i, sy = j;
      if (g[i][j] == 'Y') block[i][j] = 1;
      if (isdigit(g[i][j]) and g[i][j] != '0') {
        scientist[i][j] = g[i][j] - '0';
        person.push_back(pair<int, int>(i, j));
      }
    }
  }
  dinic::s = 0, dinic::t = 2 * n * n + 1;
  dinic::init();
  for (int i = 1; i <= n; i++) {
    scanf("%s", g[i] + 1);
    for (int j = 1; j <= n; j++)
      if (isdigit(g[i][j]) and g[i][j] != '0') {
        capsule[i][j] = g[i][j] - '0';
        dinic::add_double(n * n + getIndex(i, j), dinic::t, capsule[i][j]);
      }
  }
  memset(dis, 0x3f, sizeof dis);
  dis[sx][sy] = 0;
  queue<pair<int, int> > que;
  que.push(pair<int, int>(sx, sy));
  while (que.size()) {
    pair<int, int> p = que.front();
    que.pop();
    for (int i = 0; i < 4; i++) {
      int nx = p.first + dir[i][0];
      int ny = p.second + dir[i][1];
      if (nx < 1 or nx > n or ny < 1 or ny > n or block[nx][ny]) continue;
      if (dis[nx][ny] > dis[p.first][p.second] + 1) {
        dis[nx][ny] = dis[p.first][p.second] + 1;
        que.push(pair<int, int>(nx, ny));
      }
    }
  }
  for (int i = 0; i < person.size(); i++) {
    int x = person[i].first, y = person[i].second;
    int id = getIndex(x, y);
    dinic::add_double(dinic::s, id, scientist[x][y]);
    memset(kyori, 0x3f, sizeof kyori);
    que.push(pair<int, int>(x, y));
    kyori[x][y] = 0;
    while (que.size()) {
      pair<int, int> p = que.front();
      que.pop();
      if (capsule[p.first][p.second]) {
        dinic::add_double(id, n * n + getIndex(p.first, p.second),
                          capsule[p.first][p.second]);
        if (dis[p.first][p.second] <= kyori[p.first][p.second]) continue;
      }
      for (int i = 0; i < 4; i++) {
        int nx = p.first + dir[i][0];
        int ny = p.second + dir[i][1];
        if (nx < 1 or nx > n or ny < 1 or ny > n or block[nx][ny]) continue;
        int nd = kyori[p.first][p.second] + 1;
        if (dis[nx][ny] > nd or (dis[nx][ny] == nd and capsule[nx][ny])) {
          if (kyori[nx][ny] > nd and nd <= t) {
            kyori[nx][ny] = nd;
            que.push(pair<int, int>(nx, ny));
          }
        }
      }
    }
  }
  int ans = dinic::MaxFlow();
  printf("%d\n", ans);
  return 0;
}
