#include<bits/stdc++.h>
using namespace std;

using ll = long long;
#define f first
#define s second
template<class T> using V = vector<T>; 
using vi = V<int>;
using vpi = V<pair<int,int>>;
#define sz(x) int((x).size())
#define pb push_back
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define each(a,x) for (auto& a: x)
#define all(x) begin(x), end(x)
template<class T> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set $a = \min(a,b)$

struct MCMF { // 0-based, archi direzionati
    using F = int; using C = ll; // flow type, cost type
    struct Edge { int to, rev; F flo, cap; C cost; };
    int N; V<C> p, dist; vpi pre; V<V<Edge>> adj;
    void init(int _N) { N = _N;
        p.resize(N),adj.resize(N),dist.resize(N),pre.resize(N);}
    void ae(int u, int v, F cap, C cost) { assert(cap >= 0); 
        adj[u].pb({v,sz(adj[v]),0,cap,cost}); 
        adj[v].pb({u,sz(adj[u])-1,0,0,-cost});
    }
    //send flow through lowest cost path
    bool path(int s, int t) {
        const C inf = numeric_limits<C>::max(); 
        dist.assign(N,inf);
        using T = pair<C,int>;
        queue<T> todo;//(or queue<T>)
        todo.push({dist[s] = 0,s}); 
        while (sz(todo)) { // Dijkstra (or SPFA)
            T x = todo.front(); todo.pop(); //(or todo.front())
            if (x.f > dist[x.s]) x.f = dist[x.s]; //(or x.f = dist[x.s])
            //all weights should be non-negative
            each(e,adj[x.s]) {
                if (e.flo < e.cap && ckmin(dist[e.to],
                    x.f+e.cost+p[x.s]-p[e.to])) {
                    pre[e.to]={x.s,e.rev};
                    todo.push({dist[e.to],e.to});
                }
            }
        } // if costs are doubles, add some EPS so you 
        // don't traverse ~0-weight cycle repeatedly
        return dist[t] != inf; // true if augmenting path
    }
    pair<F,C> calc(int s, int t) { assert(s != t);
        F0R(_,5)F0R(i,N)each(e,adj[i])//utile con grafi densi...
          if(e.cap)ckmin(p[e.to],p[i]+e.cost);//e archi negativi
        F totFlow = 0; C totCost = 0;
        while (path(s,t)) { // p -> potentials for Dijkstra
            F0R(i,N)p[i]+=dist[i];//don't matter for unreachable
            F df = numeric_limits<F>::max();
            for (int x = t; x != s; x = pre[x].f) {
                Edge& e = adj[pre[x].f][adj[x][pre[x].s].rev]; 
                ckmin(df,e.cap-e.flo); }
            totFlow += df; totCost += (p[t]-p[s])*df;
            for (int x = t; x != s; x = pre[x].f) {
                Edge& e = adj[x][pre[x].s]; e.flo -= df;
                adj[pre[x].f][e.rev].flo += df;
            }
        } // get max flow you can send along path
        return {totFlow,totCost};
    }
};

void solve(int t){
    int n,k;
    cin>>n>>k;
    
    MCMF ds;
    int source = n+k, sink = n+k+1;
    ds.init(n+k+2);
    
    for(int i=0;i<n;i++){
        ds.ae(source,i,1,0);
        for(int j=0;j<k;j++){
            int c;
            cin>>c;
            ds.ae(i,n+j,1,c);
        }
    }
    
    for(int i=0;i<k;i++){
        int a;
        cin>>a;
        ds.ae(n+i,sink,a,0);
    }
    
    cout<<ds.calc(source,sink).second<<"\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve(i);
    
    return 0;
}