1 #include <iostream>
 2 #include <cstdio>
 3 #include <string>
 4 #include <queue>
 5 #include <vector>
 6 #include <map>
 7 #include <algorithm>
 8 #include <cstring>
 9 #include <cctype>
10 #include <cstdlib>
11 #include <cmath>
12 #include <ctime>
13 using    namespace    std;
14 
15 const    int    SIZE = 30;
16 bool    VIS[SIZE];
17 int    N;
18 struct    Node
19 {
20     int    vec,cost;
21     bool    operator <(const Node & r) const
22     {
23         return    cost > r.cost;
24     }
25 };
26 vector<Node>    G[SIZE];
27 
28 int    prime(void);
29 int    main(void)
30 {
31     char    ch;
32     int    from,to,cost,k;
33     Node    temp;
34 
35     while(scanf("%d",&N) != EOF && N)
36     {
37         for(int i = 0;i < N;i ++)
38             G[i].clear();
39         for(int i = 0;i < N - 1;i ++)
40         {
41             scanf(" %c%d",&ch,&k);
42             from = ch - ‘A‘;
43             while(k --)
44             {
45                 scanf(" %c%d",&ch,&cost);
46                 to = ch - ‘A‘;
47                 temp.vec = to;
48                 temp.cost = cost;
49                 G[from].push_back(temp);
50                 temp.vec = from;
51                 G[to].push_back(temp);
52             }
53         }
54         printf("%d\n",prime());
55     }
56 
57     return    0;
58 }
59 
60 int    prime(void)
61 {
62     int    ans = 0;
63     int    num = 0;
64     Node    temp;
65     priority_queue<Node>    que;
66     temp.vec = temp.cost = 0;
67     que.push(temp);
68     fill(VIS,VIS + N,false);
69 
70     while(!que.empty())
71     {
72         Node    cur = que.top();
73         que.pop();
74         if(VIS[cur.vec])
75             continue;
76         ans += cur.cost;
77         num ++;
78         VIS[cur.vec] = true;
79         if(num == N)
80             break;
81 
82         for(int i = 0;i < G[cur.vec].size();i ++)
83             if(!VIS[G[cur.vec][i].vec])
84                 que.push(G[cur.vec][i]);
85     }
86 
87     return    ans;
88 }

#include <iostream>
#include <cstdio>
#include <string>
#include <queue>
#include <vector>
#include <map>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <ctime>
using    namespace    std;

const    int    SIZE = 30;
int    FATHER[SIZE],N,NUM;
struct    Node
{
    int    from,to,cost;
}G[100];

void    ini(void);
int    find_father(int);
void    unite(int,int);
bool    same(int,int);
int    kruskal(void);
bool    comp(const Node &,const Node &);
int    main(void)
{
    char    ch;
    int    from,to,cost,k;

    while(scanf("%d",&N) && N)
    {
        ini();
        for(int i = 0;i < N - 1;i ++)
        {
            scanf(" %c%d",&ch,&k);
            from = ch - ‘A‘;
            while(k --)
            {
                scanf(" %c%d",&ch,&cost);
                to = ch - ‘A‘;
                G[NUM].from = from;
                G[NUM].to = to;
                G[NUM].cost = cost;
                NUM ++;
            }
        }
        printf("%d\n",kruskal());
    }

    return    0;
}

void    ini(void)
{
    NUM = 0;
    for(int i = 0;i <= N;i ++)
        FATHER[i] = i;
}

int    find_father(int n)
{
    if(n == FATHER[n])
        return    n;
    return    FATHER[n] = find_father(FATHER[n]);
}

void    unite(int x,int y)
{
    x = find_father(x);
    y = find_father(y);

    if(x == y)
        return    ;
    FATHER[x] = y;
}

bool    same(int x,int y)
{
    return    find_father(x) == find_father(y);
}

bool    comp(const Node & a,const Node & b)
{
    return    a.cost < b.cost;
}

int    kruskal(void)
{
    int    count = 0;
    int    ans = 0;

    sort(G,G + NUM,comp);
    for(int i = 0;i < NUM;i ++)
        if(!same(G[i].from,G[i].to))
        {
            unite(G[i].from,G[i].to);
            ans += G[i].cost;
            count ++;
            if(count == N - 1)
                break;
        }
    return    ans;
}