#include <bits/stdc++.h>
using namespace std;
const int64_t N = (int64_t)1e5 + 3;
const long long oo = (long long)1e15;
template <typename T>
class mincost_maxflow {
  struct edge {
    int64_t to;
    T cap, cost, flow;
  };
  int64_t n, s, t;
  vector<vector<int64_t>> adj;
  vector<edge> edges;
  vector<T> dist;
  vector<int64_t> from;

 public:
  const T inf = numeric_limits<T>::max();
  mincost_maxflow(int64_t n, int64_t s, int64_t t)
      : n(n), s(s), t(t), adj(n), dist(n), from(n) {}
  inline void add(int64_t u, int64_t v, const T &cap, const T &cost) {
    adj[u].push_back(edges.size());
    edges.push_back({v, cap, cost, 0});
    adj[v].push_back(edges.size());
    edges.push_back({u, 0, -cost, 0});
  }
  bool spfa() {
    fill(dist.begin(), dist.end(), inf);
    vector<int64_t> inq(n);
    queue<int64_t> q;
    dist[s] = 0, inq[s] = true, q.push(s);
    while (q.size()) {
      int64_t v = q.front();
      inq[v] = false, q.pop();
      for (int64_t i : adj[v]) {
        edge &e = edges[i];
        if (e.cap > e.flow && dist[e.to] > dist[v] + e.cost) {
          dist[e.to] = dist[v] + e.cost;
          from[e.to] = i;
          if (!inq[e.to]) {
            inq[e.to] = true, q.push(e.to);
          }
        }
      }
    }
    return dist[t] < inf;
  }
  pair<T, T> get() {
    T cost = 0, flow = 0;
    while (spfa()) {
      T delta = inf;
      for (int64_t v = t, i; v != s; v = edges[i ^ 1].to) {
        i = from[v];
        delta = min(delta, edges[i].cap - edges[i].flow);
      }
      for (int64_t v = t, i; v != s; v = edges[i ^ 1].to) {
        i = from[v];
        edges[i].flow += delta;
        edges[i ^ 1].flow -= delta;
      }
      cost += dist[t] * delta;
      flow += delta;
    }
    return {cost, flow};
  }
};
int64_t n, m, p, x;
string s, t;
bool found;
int32_t main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  if (fopen("test"
            ".inp",
            "r")) {
    freopen(
        "test"
        ".inp",
        "r", stdin);
    freopen(
        "test"
        ".out",
        "w", stdout);
  }
  cin >> n >> s >> m;
  mincost_maxflow<int64_t> f(n + 2, n + 1, n);
  while (m--) {
    cin >> t >> p;
    for (int64_t i = 0; i < n; ++i) {
      if (i + t.size() > n) break;
      found = 0;
      for (int64_t j = 0; j < t.size(); ++j)
        if (s[i + j] != t[j]) {
          found = 1;
          break;
        }
      if (!found) {
        f.add(i, i + t.size(), 1, -p);
      }
    }
  }
  cin >> x;
  for (int64_t i = 0; i < n; ++i) f.add(i, i + 1, x, 0);
  f.add(n + 1, 0, x, 0);
  cout << -f.get().first;
}
