#include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int SZ = 1010;

namespace mcmf {
    struct edge {
        int v, c, w, d;
    };
    vector<edge> gph[SZ];
    void add_edge(int u, int v, int c, int w) {
        gph[u].push_back({v, c, w, (int)gph[v].size()});
        gph[v].push_back({u, 0, -w, (int)gph[u].size() - 1});
    }
    int src, snk, dst[SZ], inq[SZ], bv[SZ], be[SZ];
    pii bfs() {
        fill(dst, dst + SZ, -1e9);
        fill(inq, inq + SZ, 0);
        dst[src] = 0;
        inq[src] = true;
        queue<int> Q;
        Q.push(src);
        while (!Q.empty()) {
            int v = Q.front(); Q.pop();
            for (int i = 0; i < gph[v].size(); i++) {
                edge e = gph[v][i];
                if (e.c > 0) {
                    if (dst[e.v] < dst[v] + e.w) {
                        dst[e.v] = dst[v] + e.w;
                        bv[e.v] = v;
                        be[e.v] = i;
                        if (!inq[e.v]) {
                            inq[e.v] = true;
                            Q.push(e.v);
                        }
                    }
                }
            }
        }
        if (dst[snk] == 1e9) return pii{0, 0};
        else {
            int fl = 1e9;
            for (int v = snk; v != src; v = bv[v]) {
                edge e = gph[bv[v]][be[v]];
                fl = min(fl, e.c);
            }
            int cst = 0;
            for (int v = snk; v != src; v = bv[v]) {
                edge e = gph[bv[v]][be[v]];
                cst += e.w * fl;
                gph[bv[v]][be[v]].c -= fl;
                gph[v][e.d].c += fl;
            }
            return pii{fl, cst};
        }
    }
    pii calc(int _src, int _snk) {
        src = _src; snk = _snk;
        int fl = 0, cst = 0;
        while (true) {
            pii ret = bfs();
            if (ret.ff == 0) {
                break;
            }
            fl += ret.ff;
            cst += ret.ss;
        }
        return {fl, cst};
    }
}

struct dsu {
    int par[SZ];
    void init() {
        iota(par, par + SZ, 0);
    }
    int find(int a) {
        return par[a] = ((par[a] == a) ? a : find(par[a]));
    }
    void merge(int a, int b) {
        a = find(a);
        b = find(b);
        par[b] = a;
    }
} dsu;

int main() {
    cin.tie(0); ios_base::sync_with_stdio(0);
    // {
    //     mcmf::add_edge(0, 1, 1, 2);
    //     auto [x, y] = mcmf::calc(0, 1);
    //     cout << x << ' ' << y << '\n';
    //     return 0;
    // }

    int n, m, k;
    cin >> n >> m >> k;
    dsu.init();
    vector<pair<int, pii>> V;
    for (int i = 0; i < m; i++) {
        int u, v, w; cin >> u >> v >> w;
        V.push_back({w, pii{u, v}});
    }
    sort(V.begin(), V.end());

    int src = 0, snk = 2 * n + 1;
    set<int> ST;
    int sz = n + 1;
    int ans = 0;
    for (int i = 1; i <= n; i++) ST.insert(i);
    for (auto [w, pr] : V) {
        auto [u, v] = pr;
        if (dsu.find(u) != dsu.find(v)) {
            u = dsu.find(u);
            v = dsu.find(v);
            ST.erase(u);
            ST.erase(v);
            mcmf::add_edge(u, sz, 1, 0);
            mcmf::add_edge(v, sz, 1, 0);
            mcmf::add_edge(sz, snk, 1, w);
            ST.insert(sz);
            dsu.merge(sz, u);
            dsu.merge(sz, v);
            ++sz;
            ans += w;
        }
    }
    for (int x : ST) {
        mcmf::add_edge(x, sz, 1, 0);
        mcmf::add_edge(sz, snk, 1, 10000);
        ++sz;
    }
    for (int i = 1; i <= k; i++) {
        mcmf::add_edge(src, 2 * n + 1 + i, 1, 0);
        int sz; cin >> sz;
        while (sz--) {
            int x; cin >> x;
            mcmf::add_edge(2 * n + 1 + i, x, 1, 0);
        }
    }
    auto [x, y] = mcmf::calc(src, snk);
    // cout << x << ' ' << y << "?\n";

    if (x != k) {
        cout << "-1\n";
    }
    else cout << ans - (y - (int)ST.size() * 10000) << '\n';
}