#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const long long INF = 1e18;

int main() {
    int M, N;
    if (fopen("binladen.inp", "r")) {
        freopen("binladen.inp", "r", stdin);
        freopen("binladen.out", "w", stdout);
    }

    cin >> M >> N;

    // dp[j]: chi phí nhỏ nhất để đến phòng j ở tầng hiện tại
    vector<long long> dp(N + 1, INF);
    dp[1] = 0; // Bắt đầu từ phòng 1, tầng 0

    for (int i = 1; i <= M; ++i) {
        // 1. Đọc chi phí thẳng xuống cho tầng i (dòng chẵn trong input)
        vector<int> v_cost(N + 1);
        for (int j = 1; j <= N; ++j) {
            cin >> v_cost[j];
        }

        // 2. Đọc chi phí ngang cho tầng i (dòng lẻ trong input)
        vector<int> h_cost(N + 1, 0);
        if (N > 1) {
            for (int j = 1; j < N; ++j) {
                cin >> h_cost[j];
            }
        }

        // Tạo dp mới cho tầng này
        vector<long long> new_dp(N + 1, INF);

        // Tính chi phí đến từng phòng ở tầng i
        for (int j = 1; j <= N; ++j) {
            // a. Từ trên xuống trực tiếp
            if (dp[j] != INF) {
                new_dp[j] = min(new_dp[j], dp[j] + v_cost[j]);
            }

            // b. Sang trái rồi xuống (nếu có)
            if (j > 1) {
                // new_dp[j] đã tính từ trên xuống, so sánh với sang trái rồi xuống
                // Lưu ý: new_dp[j-1] là chi phí tốt nhất để đến (i, j-1)
                // Từ (i, j-1) sang (i, j) tốn h_cost[j-1]
                // Từ (i, j-1) xuống (i+1, j-1) là việc của bước sau, không ảnh hưởng new_dp[j]
                // Tại bước này, new_dp[j-1] chỉ là chi phí đến (i, j-1)
                new_dp[j] = min(new_dp[j], new_dp[j-1] + h_cost[j-1]);
            }
        }

        // Cập nhật dp cho tầng tiếp theo
        dp = new_dp;
    }

    cout << dp[N] << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const long long INF = 1e18;

struct Edge {
    int to;
    int weight;
    bool operator>(const Edge& other) const {
        return weight > other.weight;
    }
};

int main() {
    if (fopen("binladen.inp", "r")) {
        freopen("binladen.inp", "r", stdin);
        freopen("binladen.out", "w", stdout);
    }

    int M, N;
    cin >> M >> N;

    // Chuyển đổi tọa độ (i, j) thành node id: id = (i-1)*N + j
    // i từ 1 đến M, j từ 1 đến N
    int total_nodes = M * N + 1; // +1 nếu dùng 1-based index
    vector<vector<Edge>> adj(total_nodes);

    // Đọc input xây dựng đồ thị
    for (int i = 1; i <= M; ++i) {
        // Dòng 1: V_cost (Xuống)
        for (int j = 1; j <= N; ++j) {
            int w;
            cin >> w;
            int u = (i - 1) * N + j;
            int v = i * N + j; // Tầng i là tảng i*N
            adj[u].push_back({v, w});
            adj[v].push_back({u, w});
        }

        // Dòng 2: H_cost (Ngang)
        if (N > 1) {
            for (int j = 1; j < N; ++j) {
                int w;
                cin >> w;
                int u = (i - 1) * N + j;
                int v = (i - 1) * N + (j + 1);
                adj[u].push_back({v, w});
                adj[v].push_back({u, w});
            }
        }
    }

    // Dijkstra từ node 1 (mặt đất/đầu phòng 1) đến node M*N (phòng N cuối)
    int start_node = 1;
    int end_node = M * N;

    // Nếu coi mặt đất là node 0, hoặc node 1 là mặt đất. 
    // Input bắt đầu từ trên xuống, ta có thể coi node 1 là điểm bắt đầu.
    // Tuy nhiên, input dòng đầu là chi phí từ trên xuống phòng 1.
    // Dùng Dijkstra trên đồ thị đã xây dựng.

    priority_queue<long long, vector<long long>, greater<long long>> dist;
    vector<long long> d(total_nodes, INF);

    d[start_node] = 0;
    dist.push(0);

    while (!dist.empty()) {
        long long u = dist.top(); 
        dist.pop();

        // Lazy deletion
        if (u > d[u]) continue;

        if (u == end_node) break;

        // Duyệt邻居
        // Code này cần map lại node ID cho đúng
    }

    // Code Dijkstra đầy đủ cần map node
    // Do M up to 2222, N up to 10, total nodes ~ 22220.
    // Dijkstra O(E log V) hoàn toàn khả thi.
    // Tuy nhiên, DP là tối ưu nhất.

    return 0;
}