现在小朋友们最喜欢的"喜羊羊与灰太狼",话说灰太狼抓羊不到，但抓兔子还是比较在行的，
而且现在的兔子还比较笨，它们只有两个窝，现在你做为狼王，面对下面这样一个网格的地形：
左上角点为(1,1),右下角点为(N,M)(上图中N=4,M=5).有以下三种类型的道路
1:(x,y)<==>(x+1,y)
2:(x,y)<==>(x,y+1)
3:(x,y)<==>(x+1,y+1)
道路上的权值表示这条路上最多能够通过的兔子数，道路是无向的. 左上角和右下角为兔子的两个窝，
开始时所有的兔子都聚集在左上角(1,1)的窝里，现在它们要跑到右下解(N,M)的窝中去，狼王开始伏击
这些兔子.当然为了保险起见，如果一条道路上最多通过的兔子数为K，狼王需要安排同样数量的K只狼，
才能完全封锁这条道路，你需要帮助狼王安排一个伏击方案，使得在将兔子一网打尽的前提下，参与的
狼的数量要最小。因为狼还要去找喜羊羊麻烦.
Input
第一行为N,M.表示网格的大小，N,M均小于等于1000.
接下来分三部分
第一部分共N行，每行M-1个数，表示横向道路的权值.
第二部分共N-1行，每行M个数，表示纵向道路的权值.
第三部分共N-1行，每行M-1个数，表示斜向道路的权值.
输入文件保证不超过10M
Output
输出一个整数，表示参与伏击的狼的最小数量.
Sample Input
3 4
5 6 4
4 3 1
7 5 3
5 6 7 8
8 7 6 5
5 5 5
6 6 6
Sample Output
14
Hint
2015.4.16新加数据一组，可能会卡掉从前可以过的程序。
最小割最大流；
套个dinic即可，
有点卡常
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<bitset>
#include<ctime>
#include<deque>
#include<stack>
#include<functional>
#include<sstream>
//#include<cctype>
//#pragma GCC optimize("O3")
using namespace std;
#define maxn 200005
#define inf 0x3f3f3f3f
#define INF 0x7fffffff
#define rdint(x) scanf("%d",&x)
#define rdllt(x) scanf("%lld",&x)
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int U;
#define ms(x) memset((x),0,sizeof(x))
const int mod = 10000007;
#define Mod 20100403
#define sq(x) (x)*(x)
#define eps 1e-7
typedef pair<int, int> pii;
#define pi acos(-1.0)
const int N = 1005;
using namespace std;
inline void read(int &x) {
x = 0; char c = getchar();
while(!isdigit(c)) c = getchar();
while(isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
}
struct node{
int fr, to, va, nxt;
}edge[N * N * 6];
int head[N * N], cnt;
inline void add_edge(int u, int v, int w) {
edge[cnt].fr = u, edge[cnt].to = v, edge[cnt].va = w;
edge[cnt].nxt = head[u], head[u] = cnt++;
edge[cnt].fr = v, edge[cnt].to = u, edge[cnt].va = w;
edge[cnt].nxt = head[v], head[v] = cnt++;
}
int st, ed, rk[N * N];
int BFS() {
queue<int> q;
memset(rk, 0, sizeof rk);
rk[st] = 1;
q.push(st);
while(!q.empty()) {
int tmp = q.front();
q.pop();
for(int i = head[tmp]; i != -1; i = edge[i].nxt) {
int o = edge[i].to;
if(rk[o] || edge[i].va <= 0) continue;
rk[o] = rk[tmp] + 1;
q.push(o);
}
}
return rk[ed];
}
int dfs(int u, int flow) {
if(u == ed) return flow;
int add = 0;
for(int i = head[u]; i != -1 && add < flow; i = edge[i].nxt) {
int v = edge[i].to;
if(rk[v] != rk[u] + 1 || !edge[i].va) continue;
int tmpadd = dfs(v, min(edge[i].va, flow - add));
if(!tmpadd) { //当前弧优化
rk[v] = -1;
continue;
}
edge[i].va -= tmpadd, edge[i ^ 1].va += tmpadd;
add += tmpadd;
}
return add;
}
int ans;
void dinic() {
while(BFS()) ans += dfs(st, inf);
}
int n, m;
inline int pos(int i, int j) {
return (i - 1) * m + j;
}
int main() {
memset(head, -1, sizeof head);
read(n), read(m);
int tmp;
st = 1, ed = pos(n, m);
for(int i = 1; i <= n; ++i) {
for(int j = 1; j < m; ++j)
read(tmp), add_edge(pos(i, j), pos(i, j + 1), tmp);
}
for(int i = 1; i < n; ++i) {
for(int j = 1; j <= m; ++j)
read(tmp), add_edge(pos(i, j), pos(i + 1, j), tmp);
}
for(int i = 1; i < n; ++i) {
for(int j = 1; j < m; ++j)
read(tmp), add_edge(pos(i, j),pos(i + 1, j + 1), tmp);
}
dinic();
cout<<ans<<endl;
return 0;
}