#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <set>
#include <cstring>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <random>
#include <cstdlib>

#define debug(x) std::cout << #x << " " << (x) << '\n';
#define pb push_back
#define mp std::make_pair
#define remax(a, b) a = std::max((a), (b));
#define remin(a, b) a = std::min((a), (b));

const int32_t INF = 2e9;

struct Edge {
	int32_t a, b, c;
};

struct maximum_bipartite_matching {
	int32_t nl, nr, mbm = 0;
	std::vector<bool> v;
	std::vector<int32_t> ml, mr, d;
	std::vector<std::vector<int32_t>> &e;

	maximum_bipartite_matching(int32_t nl, int32_t nr, std::vector<std::vector<int32_t>> &e)
			: nl(nl), nr(nr), ml(nl, -1), mr(nr, -1), e(e) {
		int32_t prv = 0;
		do {
			prv = mbm;
			d.assign(nr, INF);
			std::queue<int32_t> q;
			for(int32_t i = 0; i < nl; i++) {
				if(ml[i] == -1) {
					for(auto j : e[i]) {
						if(d[j] == INF) {
							d[j] = 0;
							q.push(j);
						}
					}
				}
			}

			while(!q.empty()) {
				int32_t i = q.front();
				q.pop();

				if(mr[i] == -1) {
					for(int32_t j = 0; j < nr; j++) {
						if(d[j] > d[i]) {
							d[j] = INF;
						}
					}
					break;
				}

				for(auto j : e[mr[i]]) {
					if(d[j] == INF) {
						d[j] = d[i] + 1;
						q.push(j);
					}
				}
			}

			for(int32_t i = 0; i < nl; i++) {
				if(ml[i] == -1) {
					mbm += findPath(i);
				}
			}
		} while(mbm > prv);
	}

	bool findPath(int32_t i, int32_t l = 0) {
		for(auto j : e[i]) {
			if(d[j] == l) {
				d[j] = INF;
				if(mr[j] == -1 || findPath(mr[j], l + 1)) {
					ml[i] = j;
					mr[j] = i;
					return true;
				}
			}
		}

		return false;
	}
};

bool check(std::vector<std::vector<int32_t>> &x, int32_t cntComps) {
	maximum_bipartite_matching mbm(x.size(), cntComps, x);
	return (mbm.mbm == x.size());
}

std::vector<std::vector<int32_t>> mergeComps(
			std::vector<std::vector<int32_t>> &comps, int32_t comp1, int32_t comp2) {
	std::vector<std::vector<int32_t>> newComps;

	for(int32_t i = 0; i < comps.size(); i++) {
		if(i != comp1 && i != comp2) {
			newComps.pb(comps[i]);
		}
	}

	newComps.pb(comps[comp1]);
	for(auto i : comps[comp2]) {
		newComps.back().pb(i);
	}

	return newComps;
}

int main() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int32_t n, r, g;
	std::cin >> n >> r >> g;

	std::vector<Edge> edges(r);
	for(int32_t i = 0; i < r; i++) {
		std::cin >> edges[i].a >> edges[i].b >> edges[i].c;
	}

	std::vector<std::vector<int32_t>> v(g);
	for(int32_t i = 0; i < g; i++) {
		int32_t k;
		std::cin >> k;

		v[i].resize(k);
		for(int32_t j = 0; j < k; j++) {
			std::cin >> v[i][j];
		}
	}

	std::sort(edges.begin(), edges.end(), [](Edge e1, Edge e2) {
				return e1.c < e2.c;
			});

	std::vector<int32_t> compInd(n + 1);
	std::vector<std::vector<int32_t>> comps;
	for(int32_t i = 1; i <= n; i++) {
		comps.pb({ i });
		compInd[i] = i - 1;
	}

	int32_t ans = 0;
	for(int32_t i = 0; i < r && comps.size() > g; i++) {
		if(compInd[edges[i].a] == compInd[edges[i].b]) continue;

		int32_t comp1 = compInd[edges[i].a];
		int32_t comp2 = compInd[edges[i].b];

		std::vector<std::vector<int32_t>> x(g);
		for(int32_t i = 0; i < g; i++) {
			for(auto &y : v[i]) {
				if(compInd[y] == comp1) {
					x[i].pb(comp2);
				}
				else {
					x[i].pb(compInd[y]);
				}
			}
		}

		if(check(x, comps.size())) {
			comps = mergeComps(comps, comp1, comp2);
			for(int32_t c = 0; c < comps.size(); c++) {
				for(auto &y : comps[c]) {
					compInd[y] = c;
				}
			}
			ans += edges[i].c;
		}
	}
	
	std::cout << ans << '\n';
}