/// @author Camillus <3
#include "bits/stdc++.h"
#define int long long
using namespace std;

struct segment_tree {
    struct node {
        int val = INT32_MAX;
        int add = 0;
    };

    vector<node> tree;
    int size = 0;

    void apply(int x, int v) {
        tree[x].val += v;
        tree[x].add += v;
    }

    void push(int x) {
        if (tree[x].add) {
            apply(x * 2 + 1, tree[x].add);
            apply(x * 2 + 2, tree[x].add);
            tree[x].add = 0;
        }
    }

    void pull(int x) {
        tree[x].val = min(tree[x * 2 + 1].val, tree[x * 2 + 2].val);
    }

    segment_tree() = default;

    segment_tree(int n) {
        size = 1;
        while (size < n) {
            size *= 2;
        }
        tree.resize(size * 2 - 1);
    }

    void set(int i, int v) {
        int x = size + i - 1;
        tree[x].val = v;

        while (x) {
            x = (x - 1) / 2;
            pull(x);
        }
    }

    int get(int l, int r, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = size;
        }

        if (l <= lx && rx <= r) {
            return tree[x].val;
        }

        if (l >= rx || lx >= r) {
            return INT32_MAX;
        }

        push(x);

        return min(
                get(l, r, x * 2 + 1, lx, (lx + rx) / 2),
                get(l, r, x * 2 + 2, (lx + rx) / 2, rx)
        );
    }

    void add(int l, int r, int v, int x = 0, int lx = 0, int rx = -1) {
        if (rx == -1) {
            rx = size;
        }

        if (l <= lx && rx <= r) {
            apply(x, v);
            return;
        }

        if (l >= rx || lx >= r) {
            return;
        }

        push(x);
        add(l, r, v, x * 2 + 1, lx, (lx + rx) / 2);
        add(l, r, v, x * 2 + 2, (lx + rx) / 2, rx);
        pull(x);
    }
};

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

    int n, t, s;
    cin >> n >> t >> s;

    vector<int> points(t + 1);
    for (int i = 1; i <= t; i++) {
        cin >> points[i];
    }

    vector<vector<bool>> solved(n, vector<bool>(t + 1));
    for (int i = 0; i < n; i++) {
        for (int j = 1; j <= t; j++) {
            char x;
            cin >> x;

            solved[i][j] = (x == '1');
        }
    }

    vector<vector<int>> dp(s + 1, vector<int>(t + 1, INT32_MAX));
    dp[0][0] = 0;

    for (int i = 1; i <= s; i++) {
        vector<vector<int>> A(n);
        vector<int> B(n);
        segment_tree st(t + 1);

        for (int j = 1; j <= t; j++) {
            st.set(j, dp[i - 1][j - 1]);
            for (int p = 0; p < n; p++) {
                if (solved[p][j]) {
                    A[p].push_back(j);
                    st.add(B[p] + 1, j + 1, points[j]);
                } else {
                    for (int _j : A[p]) {
                        st.add(B[p] + 1, _j + 1, -points[_j]);
                    }
                    A[p].resize(0);
                    B[p] = j;
                }
            }
            dp[i][j] = min(dp[i][j], st.get(0, j + 1));
        }
    }

    for (int i = 1; i <= s; i++) {
        cout << dp[i][t] << '\n';
    }
    return 0;
}