#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr Int INF = 1001001001001001001LL;

int N, M;
vector<int> C;
vector<vector<Int>> A;

bool checkTrivial() {
  for (int y = 0; y < N; ++y) {
    if (C[y] && A[0][y]) return false;
  }
  for (int x = 0; x < M; ++x) {
    bool has0 = false;
    for (int y = 0; y < N; ++y) has0 = has0 || !A[x][y];
    if (!has0) return false;
  }
  return true;
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%d", &N, &M);
    C.resize(N);
    for (int y = 0; y < N; ++y) {
      scanf("%d", &C[y]);
    }
    A.assign(M, vector<Int>(N));
    for (int x = 0; x < M; ++x) for (int y = 0; y < N; ++y) {
      scanf("%lld", &A[x][y]);
    }
    
    if (checkTrivial()) {
      /*
        single character
        after cleaning up A[0, x)[l, r), cost dp[x][l][r]
        greedy backward
        ~~> no l < l' < r' < r
        ~~> determined by (l + r)
      */
      vector<vector<pair<int, int>>> lr(M, vector<pair<int, int>>(2*N, make_pair(-1, -1)));
      vector<vector<Int>> dp(M, vector<Int>(2*N, INF));
      auto update = [&](int x, int l, int r, Int c) -> void {
        if (!~lr[x][l + r].first) lr[x][l + r] = make_pair(l, r);
        assert(lr[x][l + r] == make_pair(l, r));
        chmin(dp[x][l + r], c);
      };
      for (int y = 0; y < N; ++y) if (!A[M - 1][y]) {
        update(M - 1, y, y + 1, 0);
      }
      for (int x = M - 1; --x >= 0; ) {
        vector<int> zero(N + 1, 0);
        vector<Int> sum(N + 1, 0);
        for (int y = 0; y < N; ++y) {
          zero[y + 1] = zero[y] + ((!A[x][y]) ? 1 : 0);
          sum[y + 1] = sum[y] + A[x][y];
        }
        vector<int> prv(N + 1, -1), nxt(N + 1, N);
        for (int y = 0; y < N; ++y) if (!A[x][y]) prv[y + 1] = nxt[y] = y;
        for (int y = 0; y < N; ++y) chmax(prv[y + 1], prv[y]);
        for (int y = N; --y >= 0; ) chmin(nxt[y], nxt[y + 1]);
        for (int s = 0; s < 2*N; ++s) if (~lr[x + 1][s].first) {
          const int l = lr[x + 1][s].first;
          const int r = lr[x + 1][s].second;
          const Int c = dp[x + 1][s];
          if (zero[r] - zero[l]) {
            update(x, l, r, c + (sum[r] - sum[l]));
          } else {
            if (0 <= prv[l]) update(x, prv[l], r, c + (sum[r] - sum[prv[l]]));
            if (nxt[r] < N) update(x, l, nxt[r] + 1, c + (sum[nxt[r] + 1] - sum[l]));
          }
        }
// for(int s=0;s<2*N;++s)if(~lr[x][s].first)cerr<<lr[x][s]<<":"<<dp[x][s]<<"  ";cerr<<endl;
      }
      /*
        gather in the first round
        | |>|>|*|*|<| |
          1 1 1   2 2  
      */
      vector<vector<pair<Int, int>>> graph(N + 1);
      for (int s = 0; s < 2*N; ++s) if (~lr[0][s].first) {
        const int l = lr[0][s].first;
        const int r = lr[0][s].second;
        const Int c = dp[0][s];
        graph[l].emplace_back(c, r);
      }
      vector<Int> DP0(N + 1, INF), DP1(N + 1, INF), DP2(N + 1, INF);
      DP0[0] = DP1[0] = 0;
      for (int y = 0; ; ++y) {
        chmin(DP0[y], DP2[y]);
        chmin(DP1[y], DP0[y]);
        for (const auto &e : graph[y]) chmin(DP2[e.second], DP1[y] + e.first);
        if (y == N) break;
        if (!C[y]) chmin(DP0[y + 1], DP0[y]);
        chmin(DP1[y + 1], DP1[y] + A[0][y]);
        chmin(DP2[y + 1], DP2[y] + A[0][y]);
      }
// cerr<<DP0<<" "<<DP1<<" "<<DP2<<endl;
      printf("%lld\n", DP0[N]);
    } else {
      puts("-1");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}