import std.stdio, std.array, std.string, std.conv, std.algorithm; import std.typecons, std.range, std.random, std.math, std.container; import std.numeric, std.bigint, core.bitop, core.stdc.string; void main(){ auto s = readln.split.map!(to!int); auto H = s[0]; auto W = s[1]; auto A = iota(H).map!(_ => readln.split.map!(to!long).array).array; auto R = readln.split.map!(to!long).array; auto C = readln.split.map!(to!long).array; int source = H + W; int sink = H + W + 1; auto ff = new FordFulkerson!long(H+W+2, source, sink); foreach (i; 0..H) { ff.add_edge(source, i, A[i].sum); ff.add_edge(i, sink, R[i]); } foreach (j; 0..W) { ff.add_edge(H+j, sink, C[j]); } foreach (i; 0..H) foreach (j; 0..W) { ff.add_edge(i, H+j, A[i][j]); } writeln(R.sum + C.sum - ff.run); } class FordFulkerson(T) { int N, source, sink; int[][] adj; T[][] flow; bool[] used; this(int n, int s, int t) { N = n; source = s; sink = t; assert (s >= 0 && s < N && t >= 0 && t < N); adj = new int[][](N); flow = new T[][](N, N); used = new bool[](N); } void add_edge(int from, int to, T cap) { adj[from] ~= to; adj[to] ~= from; flow[from][to] = cap; } T dfs(int v, T min_cap) { if (v == sink) return min_cap; if (used[v]) return 0; used[v] = true; foreach (to; adj[v]) { if (!used[to] && flow[v][to] > 0) { auto bottleneck = dfs(to, min(min_cap, flow[v][to])); if (bottleneck == 0) continue; flow[v][to] -= bottleneck; flow[to][v] += bottleneck; return bottleneck; } } return 0; } T run() { T ret = 0; while (true) { foreach (i; 0..N) used[i] = false; T f = dfs(source, T.max); if (f > 0) ret += f; else return ret; } } }