#include <map>

#include <set>

#include <cmath>

#include <ctime>

#include <stack>

#include <queue>

#include <cstdio>

#include <cctype>

#include <bitset>

#include <string>

#include <vector>

#include <cstring>

#include <iostream>

#include <algorithm>

#include <functional>

#define fuck(x) cout<<"["<<x<<"]";

#define FIN freopen("input.txt","r",stdin);

#define FOUT freopen("output.txt","w+",stdout);

//#pragma comment(linker, "/STACK:102400000,102400000")

const int INF = 0x3f3f3f3f;

const int maxn = ;

using namespace std;

struct Edge{

  int u, v, d;

  Edge() {}

  Edge(int a, int b, int c) : u(a), v(b), d(c) {}

  bool operator < (const Edge &e) const {

    return d < e.d;

  }

};

int n, m, k;

int cnt;

int ans;

int f[maxn]; // 并查集

map<string, int> nodes;

vector<Edge> edges;

Edge dp[maxn];

int g[maxn][maxn];

bool tree[maxn][maxn]; // tree[i][j]=true表示<i, j>这条边在最小生成树中

int minEdge[maxn];

int find(int p) {

  if (p == f[p]) return f[p];

  return f[p] = find(f[p]);

}

void unite(int p, int q) {

  f[find(p)] = find(q);

}

void kruskal() {

  sort(edges.begin(), edges.end());

  for (int i = ; i < edges.size(); i++) {

    int p = edges[i].u;

    int q = edges[i].v;

    if (p ==  || q == ) continue; // 忽略根节点

    if (find(p) != find(q)) {

      unite(p, q);

      tree[p][q] = tree[q][p] = ;

      ans += edges[i].d;

    }

  }

}

void dfs(int cur, int pre) {

  for (int i = ; i <= cnt; i++) {

    if (i == pre || !tree[cur][i]) continue;

    if (dp[i].d == -) {

      if (dp[cur].d > g[cur][i]) dp[i] = dp[cur];

      else {

        dp[i].u = cur;

        dp[i].v = i;

        dp[i].d = g[cur][i];

      }

    }

    dfs(i, cur);

  }

}

void solve() {

  int keyPoint[maxn];

  for (int i = ; i <= cnt; i++) {

    if (g[][i] != INF) {

      // 点i在哪颗最小生成树中

      int color = find(i);

      // 每颗最小生成树中距离根节点最近的点与根节点的距离

      if (minEdge[color] > g[][i]) {

        minEdge[color] = g[][i];

        keyPoint[color] = i;

      }

    }

  }

  for (int i = ; i <= cnt; i++) {

    if (minEdge[i] != INF) {

      m++;

      tree[][keyPoint[i]] = tree[keyPoint[i]][] = ;

      ans += g[][keyPoint[i]];

    }

  }

  // 由i-1度生成树得i度生成树

  for (int i = m + ; i <= k; i++) {

    memset(dp, -, sizeof(dp));

    dp[].d = -INF;

    for (int j = ; j <= cnt; j++)

      if (tree[][j]) dp[j].d = -INF;

    dfs(, -); // dp预处理

    int idx, minnum = INF;

    for (int j = ; j <= cnt; j++) {

      if (minnum > g[][j] - dp[j].d) {

        minnum = g[][j] - dp[j].d;

        idx = j;

      }

    }

    if (minnum >= ) break;

    tree[][idx] = tree[idx][] = ;

    tree[dp[idx].u][dp[idx].v] = tree[dp[idx].v][dp[idx].u] = ;

    ans += minnum;

  }

}

void init() {

  memset(g, 0x3f, sizeof(g));

  memset(tree, , sizeof(tree));

  memset(minEdge, 0x3f, sizeof(minEdge));

  m = ;

  cnt = ;

  ans = ;

  nodes["Park"] = ;

  for (int i = ; i < maxn; i++)

    f[i] = i;

}

int main() {

#ifndef ONLINE_JUDGE

  FIN

#endif

  scanf("%d", &n);

  string s1, s2;

  int d;

  init();

  for (int i = ; i <= n; i++) {

    cin >> s1 >> s2 >> d;

    if (!nodes[s1]) nodes[s1] = ++cnt;

    if (!nodes[s2]) nodes[s2] = ++cnt;

    int u = nodes[s1], v = nodes[s2];

    edges.push_back(Edge(u, v, d));

    g[u][v] = g[v][u] = min(g[u][v], d);

  }

  scanf("%d", &k);

  kruskal(); // 忽略根节点先计算一次最小生成树，此时得到一个森林

  solve();

  printf("Total miles driven: %d\n", ans);

  return ;

}