#include <bits/stdc++.h>
#define rep(i,l,r) for(int i=l; i<=r; i++)
#define IOS {cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);}
using namespace std;

struct node {
    int to, next, flow, cost;
} ed[2000010];

typedef int ll;
typedef pair<ll, int> P;

int s, t, head[100010], sz = -1, vis[100010];
ll spend, dis[100010], h[100010], c[50010][11];

void addEdge(int from, int to, int flow, int cost) {
    sz++;
    ed[sz].to = to;
    ed[sz].next = head[from];
    ed[sz].flow = flow;
    ed[sz].cost = cost;
    head[from] = sz;
}

void add(int from, int to, int flow, int cost) {
    addEdge(from, to, flow, cost);
    addEdge(to, from, 0, -cost);
}

bool dij(int s, int t) {
    memset(vis, 0, sizeof(vis));
    for (int i =  0; i <=t ;i++) dis[i] = 1e9;
    priority_queue<P, vector<P>, greater<P> > q;
    q.push(P(0, t));
    dis[t] = 0;
    // cout <<s;
    while (!q.empty()) {
        int u = q.top().second;
        q.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for (int i = head[u]; i!=-1; i = ed[i].next) {
            int v = ed[i].to;
            if (ed[i ^ 1].flow && dis[v] > dis[u] + (h[u] - h[v] + ed[i^1].cost)) {
                dis[v] = dis[u] + (h[u] - h[v] + ed[i^1].cost);
                q.push(P(dis[v], v));
                // cout << dis[v];
            }
        }
    }
    return dis[s] != ll(1e9);
}

bool spfa(int s, int t) {
    memset(vis, 0, sizeof(vis));
    for (int i = 0;i <= t;i++) dis[i] = 1e9;
    dis[t] = 0;
    vis[t] = 1;
    queue <int> q;
    q.push(t);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for (int i = head[u];i != -1;i = ed[i].next) {
            int v = ed[i].to;
            if (ed[i ^ 1].flow && dis[v] > dis[u] - ed[i].cost) {
                dis[v] = dis[u] - ed[i].cost;
                if (!vis[v]) {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    return dis[s] != 1e9;
}

int dfs(int u, int low) {
    if (u == t) {
        vis[t] = 1;
        return low;
    }
    int used = 0;
    vis[u] = 1;
    for (int i = head[u];~i;i = ed[i].next) {
        int v = ed[i].to;
        if (!vis[v] && ed[i].flow > 0 && dis[u] - dis[v] == ed[i].cost+h[v]-h[u]) {
            int now = dfs(v, min(low - used, ed[i].flow));
            if (now) {
                spend += 1ll*now * ed[i].cost, ed[i].flow -= now;
                ed[i ^ 1].flow += now, used += now;
            }
            if (used == low) break;
        }
    }
    return used;
}

int cost_flow() {
    int flow = 0;
    spfa(s, t);
    rep (i, 0, t) h[i] = dis[i];
    while (dij(s, t)) {
        vis[t] = 1;
        while (vis[t]) {
            memset(vis, 0, sizeof(vis));
            flow += dfs(s, 1e9);
        }
        for (int i = 0; i <= t; i++) h[i] += dis[i];
    }
    return flow;
}

P a[50010][11];

int main() {
    memset(head, -1, sizeof(head));
    int n, k;
    scanf("%d%d", &n, &k);
    s = n + k + 1;
    t = s+1;
    rep (i, 1, n) {
        add(s, i, 1, 0);
        rep (j, 1, k) {
            scanf("%d", &c[i][j]);
            a[i][j].first = c[i][j];
            a[i][j].second = j;
            // add(i, n+j, 1, x);
        }
        sort(a[i]+1, a[i]+k+1);
    }

    rep (i, 1, k) {
        int x; scanf("%d", &x);
        add(n+i, t, x, 0);
    }

    rep (i, 1, n) {
        rep (j, 1, k) {
            add(i, n+a[i][j].second, 1, a[i][j].first);
            cost_flow();
        }
    }
    
    cout << spend;

    return 0;
}