#include <iostream>
#include <array>
#include <vector>
#include <cstdint>
#include <limits>
#include <algorithm>

using SorKoltsegek = std::vector<uint64_t>;
using OszlopMatrix = std::array<std::array<uint64_t, 4>, 4>;
using OszlopKoltsegek = std::vector<OszlopMatrix>;

const auto U64MAX = std::numeric_limits<uint64_t>::max();

void beolvas(std::istream &be, SorKoltsegek &sor_koltsegek, OszlopKoltsegek &oszlop_koltsegek) {
    int n, m;
    be >> n >> m;

    sor_koltsegek.resize(n);
    for (auto &k : sor_koltsegek) {
        be >> k;
    }

    oszlop_koltsegek.resize(m);
    for (auto &o : oszlop_koltsegek) {
        for (int l = 0; l < n; l++) {
            for (int r = l; r < n; r++) {
                be >> o[l][r];
            }
        }
    }
}

// Az elozo javitott rekurziv megvalositason alapulo dinamikus programozas implementacio
uint64_t min_oszlop_koltseg_dp(int sorok_szama, size_t kifestett_sorok, const OszlopMatrix &o) {
    std::array<uint64_t, 5> dp { 0, U64MAX, U64MAX, U64MAX, U64MAX };
    for (auto utolso_sor = 0; utolso_sor < sorok_szama; utolso_sor++) {
        auto felso_min = U64MAX;
        for (auto also_kezd = utolso_sor; also_kezd >= 0; also_kezd--) {
            felso_min = std::min(felso_min, dp[also_kezd]);
            dp[utolso_sor + 1] = std::min(dp[utolso_sor + 1], felso_min + o[also_kezd][utolso_sor]);
        }

        if (kifestett_sorok & 1) {
            dp[utolso_sor + 1] = std::min(dp[utolso_sor + 1], dp[utolso_sor]);
        }
        kifestett_sorok >>= 1;
    }

    return dp[sorok_szama];
}

uint64_t feldolgoz(const SorKoltsegek &sor_koltsegek, const OszlopKoltsegek &oszlop_koltsegek) {
    // Sorok szama
    const auto n = sor_koltsegek.size();
    // Oszlopok szama
    const auto m = oszlop_koltsegek.size();
    // A sorok hatvanyhalmazanak szamossaga
    const auto max_sor_halmaz = 1 << n;

    auto min_koltseg = U64MAX;
    for (auto kifestett_sorok = 0u; kifestett_sorok < max_sor_halmaz; kifestett_sorok++) {
        uint64_t akt_koltseg = 0u;

        auto h = kifestett_sorok;
        int sor = 0;
        while (h) {
            akt_koltseg += (h & 1) * sor_koltsegek[sor++];
            h >>= 1;
        }

        for (const auto &o: oszlop_koltsegek) {
            akt_koltseg += min_oszlop_koltseg_dp(n, kifestett_sorok, o);
        }
        min_koltseg = std::min(min_koltseg, akt_koltseg);
    }

    return min_koltseg;
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    SorKoltsegek r;
    OszlopKoltsegek o;
    beolvas(std::cin, r, o);

    std::cout << feldolgoz(r, o) << std::endl;

    return 0;
}