import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

int readint() { return readln.chomp.to!int; }
int[] readints() { return readln.split.to!(int[]); }

void main() {
    int n = readint;
    int[] a;

    int[string] db; // name -> int
    for (int i = 0; i < n; i++) {
        auto ax = readln.split;
        string material = ax[0];
        int price = ax[1].to!int;

        db[material] = i;
        a ~= price;
    }

    auto uf = new UnionFind(n);
    int m = readint;
    for (int i = 0; i < m; i++) {
        auto ss = readln.split;
        // s と t は自由に交換可能
        int s = db[ss[0]];
        int t = db[ss[1]];

        // rs, rt の集合の最安値を更新
        int rs = uf.root(s);
        int rt = uf.root(t);
        uf.unite(s, t);
        a[uf.root(s)] = min(a[rs], a[rt]);
    }

    int ans = 0;
    foreach (i; 0..n) {
        ans += a[uf.root(i)];
    }
    writeln(ans);
}


class UnionFind {
    private int[] _data;
    private int[] _nexts; // 次の要素。なければ -1
    private int[] _tails; // 末尾の要素

    this(int n) {
        _data  = new int[](n + 1);
        _nexts = new int[](n + 1);
        _tails = new int[](n + 1);

        _data[] = -1;
        _nexts[] = -1;
        for (int i = 0; i < _tails.length; i++)
            _tails[i] = i;
    }

    int root(int a) {
        if (_data[a] < 0) return a;
        return _data[a] = root(_data[a]);
    }

    bool unite(int a, int b) {
        int ra = root(a);
        int rb = root(b);
        if (ra == rb) return false;
        // ra に rb を繋げる
        _data[ra] += _data[rb];
        _data[rb] = ra;

        // ra の末尾の後ろに rb を繋げる
        _nexts[_tails[ra]] = rb;
        // ra の末尾が rb の末尾になる
        _tails[ra] = _tails[rb];
        return true;
    }

    bool isSame(int a, int b) {
        return root(a) == root(b);
    }

    /// a が属する集合のサイズ
    int groupSize(int a) {
        return -_data[root(a)];
    }

    /// a が属する集合の要素全て
    void doEach(int a, void delegate(int) fn) {
        auto node = root(a);
        while (node != -1) {
            fn(node);
            node = _nexts[node];
        }
    }
}

