/**
 * @author n685
 * @date 2024-12-24 17:53:24
 */
#include "bits/stdc++.h"

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;

template <class T> constexpr T INF = T{};
template <std::floating_point T>
constexpr T INF<T> = std::numeric_limits<T>::infinity();
template <> constexpr int INF<int> = 0x3f3f3f3f; // 1061109567
template <>
constexpr long long INF<long long>
  = 0x3f3f3f3f3f3f3f3fLL; // 4557430888798830399

struct IV {
  int l, r;
  int cost;
  auto operator<=>(const IV& iv) const = default;
};
struct Node {
  int r, cost;
};

void solve() {
  int n, m;
  std::cin >> n >> m;

  std::vector<bool> c(n + 1);
  for (int i = 1; i <= n; ++i) {
    int v;
    std::cin >> v;
    c[i] = v == 1;
  }

  std::vector a(m, std::vector<int>(n + 1));
  std::vector<int> sum(n + 1);
  for (int i = 0; i < m; ++i) {
    for (int j = 1; j <= n; ++j) {
      std::cin >> a[i][j];
      sum[j] += a[i][j];
    }
  }
  for (int i = 1; i <= n; ++i) {
    if (c[i] && a[0][i] > 0) {
      std::cout << "-1\n";
      return;
    }
  }

  std::vector<IV> ii;
  ii.reserve(n);
  for (int i = 1; i <= n; ++i) {
    if (a[m - 1][i] == 0) {
      ii.emplace_back(i, i, sum[i]);
    }
  }
  for (int t = m - 2; t >= 1; --t) {
    for (int i = 1; i <= n; ++i) {
      sum[i] -= a[t + 1][i];
    }
    std::vector<int> ps = sum;
    std::partial_sum(ps.begin(), ps.end(), ps.begin());
    std::vector<int> zero;
    for (int i = 1; i <= n; ++i) {
      if (a[t][i] == 0) {
        zero.push_back(i);
      }
    }
    if (zero.empty()) {
      std::cout << "-1\n";
      return;
    }
    std::vector<IV> nii;
    for (auto [l, r, v] : ii) {
      auto it = std::lower_bound(zero.begin(), zero.end(), l);
      if (it != zero.end() && *it <= r) {
        nii.emplace_back(l, r, v);
        continue;
      }
      int nl = -1, cl = INF<int>;
      if (it != zero.begin()) {
        nl = *std::prev(it);
        cl = ps[l - 1] - ps[nl - 1];
      }
      int nr = -1, cr = INF<int>;
      if (it != zero.end()) {
        nr = *it;
        cr = ps[nr] - ps[r];
      }
      if (nl != -1) {
        nii.emplace_back(nl, r, v + cl);
      }
      if (nr != -1) {
        nii.emplace_back(l, nr, v + cr);
      }
    }
    rs::sort(nii);
    nii.erase(
      rs::unique(nii, {}, [&](const IV& iv) { return std::pair{iv.l, iv.r}; })
        .begin(),
      nii.end()
    );
    ii.swap(nii);
  }
  dbg_rproj([&](const IV& iv) { return std::pair{iv.l, iv.r}; }, ii);
  std::vector<std::vector<Node>> add(n + 1);
  for (auto [l, r, v] : ii) {
    add[l].emplace_back(r, v);
  }

  std::vector dp(n + 1, std::array{INF<int>, INF<int>, INF<int>});
  dp[0][0] = 0;
  std::deque<Node> dq;
  for (int i = 1; i <= n; ++i) {
    for (auto [r, v] : add[i]) {
      int cost = v + std::min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]});
      while (!dq.empty() && dq.back().cost >= cost) {
        dq.pop_back();
      }
      dq.emplace_back(r, cost);
    }
    while (!dq.empty() && dq.front().r < i) {
      dq.pop_front();
    }
    if (!dq.empty()) {
      int cost = dq.front().cost;
      dp[i][0] = std::min(dp[i][0], cost);
      dp[i][1] = std::min(dp[i][1], cost);
      dp[i][2] = std::min(dp[i][2], cost);
    }
    if (!c[i]) {
      dp[i][0] = std::min({dp[i][0], dp[i - 1][0], dp[i - 1][1]});
    }
    dp[i][1] = std::min(dp[i][1], dp[i - 1][1] + a[0][i]);
    dp[i][2] = std::min(
      dp[i][2],
      std::min({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]}) + a[0][i]
    );
  }
  int ans = std::min(dp[n][0], dp[n][1]);
  if (ans == INF<int>) {
    std::cout << "-1\n";
  } else {
    std::cout << std::min(dp[n][0], dp[n][1]) << '\n';
  }
}

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  int t;
  std::cin >> t;
  for (int i = 0; i < t; ++i) {
    dbg(i + 1);
    solve();
    bar();
  }
}