Cowmbat

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class MoortalCowmbat {

    public static void main(String[] args) throws IOException {
        // BufferedReader in = new BufferedReader(new
        // FileReader("D:\\Java\\USACO-Gold\\Gold\\MoortalCowmbat\\2.in"));
        BufferedReader in = new BufferedReader(new FileReader("cowmbat.in"));
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("cowmbat.out")));
        StringTokenizer tk = new StringTokenizer(in.readLine());
        int N = Integer.parseInt(tk.nextToken());
        int M = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());
        char[] c = in.readLine().toCharArray();
        int[] s = new int[N];
        int[][] adjMat = new int[M][M];
        for (int i = 0; i < N; i++) {
            s[i] = (int) (c[i] - 'a');
        }
        for (int i = 0; i < M; i++) {
            tk = new StringTokenizer(in.readLine());
            for (int j = 0; j < M; j++) {
                adjMat[i][j] = Integer.parseInt(tk.nextToken());
            }
        }
        int[][] dists = new int[M][M];
        for (int i = 0; i < M; i++) {
            dists[i] = dijkstra(adjMat, i, M);
        }

        int[][] dp = new int[N][M];
        int[][] numConsec = new int[N][M];
        for (int i = 0; i < M; i++) {
            dp[0][i] = dists[s[0]][i];
            numConsec[0][i] = 1;
        }
        for (int i = 1; i < N; i++) {
            for (int j = 0; j < M; j++) {
                dp[i][j] = Integer.MAX_VALUE;
            }
        }
        for (int i = 1; i < N; i++) {
            for (int j = 0; j < M; j++) {
                for (int k = 0; k < M; k++) {
                    if ((numConsec[i - 1][k] < K || N - i < K) && j != k) {
                        continue;
                    }
                    int toTry = dp[i - 1][k] + dists[s[i]][j];
                    if (toTry < dp[i][j]) {
                        dp[i][j] = toTry;
                        if (j == k) {
                            numConsec[i][j] = numConsec[i - 1][k] + 1;
                        } else {
                            numConsec[i][j] = 1;
                        }
                    } else if (toTry == dp[i][j]) {
                        int newConsec = 0;
                        if (j == k) {
                            newConsec = numConsec[i - 1][k] + 1;
                        } else {
                            newConsec = 1;
                        }
                        numConsec[i][j] = Math.max(numConsec[i][j], newConsec);
                    }
                }
            }
        }
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < M; i++) {
            ans = Math.min(ans, dp[N - 1][i]);
        }
        System.out.println(ans);
        out.close();
        in.close();
    }

    static int[] dijkstra(int[][] adjMat, int root, int N) {
        int[] dists = new int[N];
        Arrays.fill(dists, Integer.MAX_VALUE);
        boolean[] inSet = new boolean[N];
        dists[root] = 0;
        for (int k = 0; k < N - 1; k++) {
            int smallest = -1;
            long min = Long.MAX_VALUE;
            for (int i = 0; i < N; i++) {
                if (!inSet[i] && dists[i] < min) {
                    smallest = i;
                    min = dists[i];
                }
            }
            inSet[smallest] = true;
            for (int v = 0; v < N; v++) {
                int distsThroughU = dists[smallest] + adjMat[smallest][v];
                if (!inSet[v]) {
                    dists[v] = Math.min(dists[v], distsThroughU);
                }
            }
        }
        return dists;
    }
}