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

using SorKoltsegek = std::vector<uint64_t>;
using OszlopKoltsegek = std::vector<std::vector<std::vector<uint64_t>>>;

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

    r.resize(n);
    for (auto &akt_sor : r) {
        be >> akt_sor;
    }

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

uint64_t min_oszlop_koltseg(int sorok, int oszlop, int kifestett_sorok, const OszlopKoltsegek &c) {
    std::vector<uint64_t> dp(sorok + 1, std::numeric_limits<uint64_t>::max());

    dp[0] = 0;
    for (auto akt_sor = 0; akt_sor < sorok; akt_sor++) {
        auto min_legalabb_elso_sorig = std::numeric_limits<uint64_t>::max();
        for (auto elso_kifestendo_sor = akt_sor; elso_kifestendo_sor >= 0; elso_kifestendo_sor--) {
            min_legalabb_elso_sorig = std::min(min_legalabb_elso_sorig, dp[elso_kifestendo_sor]);
            dp[akt_sor + 1] = std::min(dp[akt_sor + 1], min_legalabb_elso_sorig + c[oszlop][elso_kifestendo_sor][akt_sor]);
        }

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

    return dp[sorok];
}

void feldolgoz(const SorKoltsegek &r, const OszlopKoltsegek &c) {
    const auto sorok = r.size();
    const auto oszlopok = c.size();
    const int max_sor_halmaz = (1 << sorok);

    auto min_koltseg = std::numeric_limits<uint64_t>::max();
    for (int kifestett_sorok = 0; kifestett_sorok < max_sor_halmaz; kifestett_sorok++) {
        uint64_t akt_koltseg = 0u;
        for (int sor = 0; sor < sorok; sor++) {
            if ((kifestett_sorok & (1 << sor)) > 0) {
                akt_koltseg += r[sor];
            }
        }

        for (int oszlop = 0; oszlop < oszlopok; oszlop++) {
            akt_koltseg += min_oszlop_koltseg(static_cast<int>(sorok), oszlop, kifestett_sorok, c);
        }
        min_koltseg = std::min(min_koltseg, akt_koltseg);
    }

    std::cout << min_koltseg << '\n';
}

int main() {
    SorKoltsegek r;
    OszlopKoltsegek c;
    beolvas(std::cin, r, c);

    feldolgoz(r, c);

    return 0;
}