#include <bits/stdc++.h>

using i64 = int64_t;
constexpr i64 INF = 1e18;

template <typename T>
class ZKW {
    struct Edge {
        int to, cap;
        T cost;
    };

    std::vector<Edge> edge;
    std::vector<std::vector<int>> adj;
    std::vector<T> d;
    std::vector<uint8_t> vist;

    int s, t;
    int flow;
    T cost;

    std::vector<int> ns;

    int dfs(int x, int f) {
        vist[x] = true;
        ns.push_back(x);
        if (x == t) {
            flow += f;
            cost += -d[s] * f;
            return f;
        }
        for (int i : adj[x]) {
            int y = edge[i].to;
            if (edge[i].cap && !vist[y] && d[x] + edge[i].cost - d[y] == 0) {
                int res = dfs(y, std::min(f, edge[i].cap));
                if (res) {
                    edge[i].cap -= res;
                    edge[i ^ 1].cap += res;
                    return res;
                }
            }
        }
        return 0;
    }
    bool relabel() {
        if (vist[t]) {
            return true;
        }
        T z = INF;
        for (int x : ns) {
            for (int i : adj[x]) {
                int y = edge[i].to;
                if (edge[i].cap && !vist[y]) {
                    z = std::min(z, d[x] + edge[i].cost - d[y]);
                }
            }
        }
        if (z == INF) {
            return false;
        }
        for (int i : ns) {
            d[i] -= z;
        }
        return true;
    }

public:
    explicit ZKW(int n) : adj(n), d(n), vist(n) {}
    void add_edge(int u, int v, int cap, T cost) {
        adj[u].push_back(edge.size());
        edge.push_back(Edge{v, cap, cost});
        adj[v].push_back(edge.size());
        edge.push_back(Edge{u, 0, -cost});
    }
    std::pair<int, T> operator()(int s, int t) {
        this->s = s;
        this->t = t;
        flow = 0;
        cost = 0;
        do {
            for (int i : ns) {
                vist[i] = false;
            }
            ns.clear();
            dfs(s, 1e9);
        } while (relabel());
        return std::make_pair(flow, cost);
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, k;
    std::cin >> n >> k;

    ZKW<i64> f(n + k + 2);
    const int s = n + k + 1, t = n + k;

    for (int i = 0; i < n; ++i) {
        f.add_edge(s, i, 1, 0);
        for (int j = n; j < n + k; ++j) {
            int c;
            std::cin >> c;
            f.add_edge(i, j, 1, c);
        }
    }
    for (int i = n; i < n + k; ++i) {
        int a;
        std::cin >> a;
        f.add_edge(i, t, a, 0);
    }

    auto [flow, cost] = f(s, t);
    assert(flow == n);
    std::cout << cost << '\n';

}