#include <bits/stdc++.h>

using namespace std;

#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define sz(a) (int)(a).size()

using vi = vector<int>;

template<class Cap, class Cost, Cap Cap_MAX = 
    numeric_limits<Cap>::max(), Cost Cost_MAX =
    numeric_limits<Cost>::max() / 4>
struct SuccessiveShortestPath{
    int n;
    struct E { int to; Cap a; Cost w; } ;
    vector<E> es;
    vector<vi> g;
    vector<Cost> h;

    SuccessiveShortestPath(int n): n(n), g(n), h(n) {}

    int addEdge(int u, int v, Cap c, Cost w) {
        // cout << "#" << u << " " << v << " " << c << " " << w << endl;
        int res = sz(es);
        g[u].push_back(sz(es)); es.push_back({v, c, w});
        g[v].push_back(sz(es)); es.push_back({u, 0, -w});
        return res;
    }

    pair<Cost, Cap> mincostflow(int src, int sink, Cap mx_flow = Cap_MAX) {
        h.assign(n, Cost_MAX);
        h[src] = 0;
        rep(rd, 1, n) rep(now, 0, n - 1) for (auto i: g[now]) {
            auto [v, c, w] = es[i];
            if (c > 0) h[v] = min(h[v], h[now] + w);
        }

        Cost cost = 0;
        Cap flow = 0;
        while (mx_flow) {
            priority_queue<pair<Cost, int> > pq;
            vector<Cost> dis(n, Cost_MAX);
            dis[src] = 0; pq.emplace(0, src);

            vi pre(n, -1), mark(n, 0);

            while(sz(pq)) {
                auto [d, now] = pq.top(); pq.pop();
                if (mark[now]) continue;
                mark[now] = 1;
                for (auto i: g[now]) {
                    auto [v, c, w] = es[i];
                    Cost off = dis[now] + w + h[now] - h[v];
                    if (c > 0 && dis[v] > off) {
                        dis[v] = off;
                        pq.emplace(-dis[v], v);
                        pre[v] = i;
                    }
                }
            }

            if (pre[sink] == -1) break;
            rep(i, 0, n - 1) if (dis[i] != Cost_MAX) h[i] += dis[i];
            Cap aug = mx_flow;
            for (int i = pre[sink]; ~i; i = pre[es[i ^ 1].to]) aug = min(aug, es[i].a);
            for (int i = pre[sink]; ~i; i = pre[es[i ^ 1].to]) es[i].a -= aug, es[i ^ 1].a += aug;
            mx_flow -= aug;
            flow += aug;
            cost += aug * h[sink];
        }

        return {cost, flow};
    }

} ;

const long long inf1 = 1e6;
const long long inf2 = 1e12;

const int maxn = 1e5 + 5;
const int maxm = 1e5 + 5;

int n, r, g;
int fa[maxn];
int block_id[maxn];
long long wei[maxm];
vector<pair<long long, pair<int, int> > > all;

vector<int> id1, id2;

inline int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }

int main(){
    scanf("%d%d%d", &n, &r, &g);
    for(int i = 1; i <= r; ++i) {
        int a, b;
        long long c; scanf("%d%d%lld", &a, &b, &c);
        all.push_back(make_pair(c, make_pair(a, b)));
    }

    sort(all.begin(), all.end());
    for (int i = 1; i <= n + all.size(); ++i) fa[i] = i;

    int tot = n * 3 + g + 5;
    SuccessiveShortestPath<int, long long> flow(tot);

    int tree_node = n + 1;

    
    long long ans = 0;
    for (auto e: all) {
        int u = e.second.first, v = e.second.second;
        long long w = e.first;
        u = find(u), v = find(v);
        if (u == v) continue;
        int z = tree_node++;
        fa[u] = z, fa[v] = z;
        flow.addEdge(u, z, 1, -inf1);
        flow.addEdge(v, z, 1, -inf1);
        wei[z] = w;
        ans += w;
    }

    int block_node = tree_node;
    for (int i = 1; i < tree_node; ++i) {
        if (find(i) == i) {
            int u = block_node++;
            block_id[i] = u;
        }
    }

    for (int i = 1; i < tree_node; ++i) {
        if (i > n) id2.push_back(flow.addEdge(i, block_id[find(i)], 1, -wei[i]));
        if (find(i) == i) flow.addEdge(i, block_id[i], 1, -inf1);
    }

    int S = 0, T = tot - 1;
    for (int i = tree_node; i < block_node; ++i) {
        id1.push_back(flow.addEdge(i, T, 1, -inf2));
        flow.addEdge(i, T, g, 0);
    }

    int k_node = block_node;
    for (int i = 0; i < g; ++i) {
        int cnt; scanf("%d", &cnt);
        int u = k_node++;
        flow.addEdge(S, u, 1, 0);
        for (int j = 0; j < cnt; ++j) {
            int x; scanf("%d", &x);
            flow.addEdge(u, x, 1, 0);
        }
    }

    auto [cost, cap] = flow.mincostflow(S, T);
    // cout << cost << " " << cap << endl;

    if (cap != g) {
        puts("-1");
        return 0;
    }
    
    for (auto e: id1) {
        if(flow.es[e].a != 0) {
            puts("-1");
            return 0;
        }
    }

    for (auto e: id2) {
        if (flow.es[e].a == 0) {
            ans += flow.es[e].w;
        }
    }

    cout << ans << endl;
    return 0;
}