#include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define ld long double
#define pb push_back
#define sws cin.tie(0)->sync_with_stdio(false);
#define endl '\n'

using namespace std;

const int N = 1e5+10;
const ll MOD = 998244353;
// const ll MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;

struct Dinitz {
  struct Edge {
    ll v, u, cap, flow=0, cost;
    Edge(ll v, ll u, ll cap, ll cost) : v(v), u(u), cap(cap), cost(cost) {}
  };

  int n, s, t;
  Dinitz(int n, int s, int t) : n(n), s(s), t(t) {
    adj.resize(n);
  }

  vector<Edge> edges;
  vector<vector<int>> adj;
  void add_edge(int v, int u, ll cap, ll cost) {
    edges.emplace_back(v, u, cap, cost);
    adj[v].pb((int)edges.size()-1);
    edges.emplace_back(u, v, 0, -cost);
    adj[u].pb((int)edges.size()-1);
  }

  vector<ll> dist;
  bool spfa() {
    dist.assign(n, LLINF);

    queue<int> Q;
    vector<bool> inqueue(n, false);

    dist[s] = 0;
    Q.push(s);
    inqueue[s] = true;

    while (!Q.empty()) {
      int v = Q.front(); Q.pop();
      inqueue[v] = false;

      for (auto eid : adj[v]) {
        auto const& e = edges[eid];
        if (e.cap - e.flow <= 0) continue;
        if (dist[e.u] > dist[e.v] + e.cost) {
          dist[e.u] = dist[e.v] + e.cost;
          if (!inqueue[e.u]) {
            Q.push(e.u);
            inqueue[e.u] = true;
          }
        }
      }
    }

    return dist[t] != LLINF;
  }

  ll cost = 0;
  vector<ll> ptr;
  ll dfs(int v, ll f) {
    if (v == t || f == 0) return f;
    for (auto &cid = ptr[v]; cid < ((int)adj[v].size());) {
      auto eid = adj[v][cid];
      auto &e = edges[eid];
      cid++;
      if (e.cap - e.flow <= 0) continue;
      if (dist[e.v] + e.cost != dist[e.u]) continue;
      ll newf = dfs(e.u, min(f, e.cap-e.flow));
      if (newf == 0) continue;
      e.flow += newf;
      edges[eid^1].flow -= newf;
      cost += e.cost * newf;
      return newf;
    }
    return 0;
  }

  ll total_flow = 0;
  pair<ll, ll> flow() {
    while (spfa()) {
      ptr.assign(n, 0);
      while (ll newf = dfs(s, LLINF))
        total_flow += newf;
    }
    return {total_flow, cost};
  }
};


int32_t main()
{
    #ifndef LOCAL
    sws;
    #endif

    int n, k; cin >> n >> k;
    int limit = n + k + 10;
    int source = limit - 1, sink = limit - 2;
    Dinitz dnc(limit, source, sink);

    vector<vector<int>> cost(n, vector<int>(k));
    for (int i=0;i<n;i++) {
        for (int j=0;j<k;j++) {
            cin >> cost[i][j];
        }
    }
    vector<int> a(k);
    for (int i=0;i<k;i++) {
        cin >> a[i];
    }


    for (int i=0;i<n;i++) {
        dnc.add_edge(source, i, 1, 0);
    }
    for (int i=0;i<n;i++) {
        for (int j=0;j<k;j++) {
            dnc.add_edge(i, j+n, 1, cost[i][j]);
        }
    }

    for (int j=0;j<k;j++) {
        dnc.add_edge(j+n, sink, a[j], 0);
    }
    
    auto [f, c] = dnc.flow();

    cout << c << endl;

    

    return 0;
}