8 ЛКШ AC

#define pragma

#ifdef pragma
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif // pragma

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define all(x) begin(x), end(x)
#define pb push_back
#define x first
#define y second
#define int long long
#define zero(two) memset(two, 0, sizeof(two))

using namespace std;
using namespace __gnu_pbds;


typedef vector<int> vi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef long double ld;
typedef vector<vi> matrix;
template<typename T>
using kawaii_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

const ld PI = atan2(0, -1);

void seriy() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(10);
    #if _offline
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

const int MAXN = 1e5 + 10;
const int ALPH = 26;
const int INF = 1e18 + 7;
const int MAXLOG = 20;
const int MOD = 998244353;
const int BASE = 47;

struct edge {
    int u, v, w;
};

vector<vector<pii>> g;
vector<vi> kek;
vi pr, sz;
vb used;
vi ch, ch2, p, ans;
int n, m, t;

int get(int a) {
    if(pr[a] == a) return a;
    return pr[a] = get(pr[pr[a]]);
}

void dfs(int u, int w, int p) {
    ans[u] = w;
    for(auto v : kek[u]) {
        if(v != p) {
            dfs(v, w, u);
        }
    }
}

void unite(int a, int b, int w) {
    a = get(a);
    b = get(b);
    if(a != b) {
        if(sz[a] < sz[b]) {
            swap(a, b);
        }
//        cerr << a << " " << b << '\n';
        if(sz[a] < t) {
            ans[a] = max(max(ans[a], ans[b]), w);
        }
        if(sz[b] < t) {
            ans[b] = max(max(ans[a], ans[b]), w);
            dfs(b, ans[b], -1);
        }
        pr[b] = a;
        kek[a].pb(b);
        sz[a] += sz[b];
        if(sz[a] >= t && !used[a]) {
            used[a] = 1;
            dfs(a, ans[a], -1);
        }
    }
}

bool cmp(edge a, edge b) {
    return a.w < b.w;
}

signed main() {
    seriy();
    cin >> n >> m >> t;
    int h[n][m];
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            cin >> h[i][j];
        }
    }
    g.resize(n * m);
    kek.resize(n * m);
    sz.resize(n * m, 1);
    pr.resize(n * m);
    for(int i = 0; i < n * m; i++) {
        pr[i] = i;
    }
    int dx[4] = {-1, 1, 0, 0};
    int dy[4] = {0, 0, -1, 1};
    vector<edge> edges;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            for(int k = 0; k < 4; k++) {
                int tox = i + dx[k];
                int toy = j + dy[k];
                if(tox > -1 && tox < n && toy > -1 && toy < m) {
                    edges.pb({i * m + j, tox * m + toy, abs(h[i][j] - h[tox][toy])});
                }
            }
        }
    }
    ans.resize(n * m);
    used.resize(n * m);
    sort(all(edges), cmp);
    for(auto i : edges) {
        if(get(i.u) != get(i.v) && (sz[i.u] < t || sz[i.v] < t)) {
            unite(i.u, i.v, i.w);
        }
    }
    int res = 0;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            int q;
            cin >> q;
//            cerr << q << " ";
//            cerr << ans[i * m + j] << " ";
            if(q) {
                res += ans[i * m + j];
            }
        }
//        cerr << '\n';
    }
    cout << res;
    return 0;
}