#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ;
typedef vector < int > vi ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()

const int MAXN = 307 ;

int n , m , k ;
struct edge {
    int x , y , len ;
};
edge hh[ MAXN * MAXN ] ;
vector < int > aux[ MAXN ] ;
int prv[ MAXN ] , rem[ MAXN ] ;
vector < int > spec[ MAXN ] ;

int get ( int x ) {
    if ( prv[ x ] == -1 ) { return x ; }
    int y = get ( prv[ x ] ) ;
    prv[ x ] = y ;
    return y ;
}

bool unite ( int x , int y ) {
    int k1 = get ( x ) , k2 = get ( y ) ;
    if ( k1 == k2 ) { return false ; }
    if ( rng ( ) % 2 == 0 ) { swap ( k1 , k2 ) ; }
    prv[ k2 ] = k1 ;
    return true ;
}


bool dfs(int a, int L, vector<vi>& g, vi& btoa, vi& A, vi& B) {
	if (A[a] != L) return 0;
	A[a] = -1;
	for (int b : g[a]) if (B[b] == L + 1) {
		B[b] = 0;
		if (btoa[b] == -1 || dfs(btoa[b], L + 1, g, btoa, A, B))
			return btoa[b] = a, 1;
	}
	return 0;
}

int hopcroftKarp(vector<vi>& g, vi& btoa) {
	int res = 0;
	vi A(g.size()), B(btoa.size()), cur, next;
	for (;;) {
		fill(all(A), 0);
		fill(all(B), 0);
		/// Find the starting nodes for BFS (i.e. layer 0).
		cur.clear();
		for (int a : btoa) if(a != -1) A[a] = -1;
		rep(a,0,sz(g)) if(A[a] == 0) cur.push_back(a);
		/// Find all layers using bfs.
		for (int lay = 1;; lay++) {
			bool islast = 0;
			next.clear();
			for (int a : cur) for (int b : g[a]) {
				if (btoa[b] == -1) {
					B[b] = lay;
					islast = 1;
				}
				else if (btoa[b] != a && !B[b]) {
					B[b] = lay;
					next.push_back(btoa[b]);
				}
			}
			if (islast) break;
			if (next.empty()) return res;
			for (int a : next) A[a] = lay;
			cur.swap(next);
		}
		/// Use DFS to scan for augmenting paths.
		rep(a,0,sz(g))
			res += dfs(a, 0, g, btoa, A, B);
	}
}


vector < vector < int > > v ;
bool fl[ MAXN ] ;

int rv[ MAXN ] ;

bool can ( ) {
    v.resize ( k ) ;
    for ( int i = 0 ; i < k ; ++ i ) {
        v[ i ].clear ( ) ;
    }
    int tp = 0 ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        rv[ i ] = 0 ;
        if ( get ( i ) == i ) { rv[ i ] = ++ tp ; }
    }
    for ( int i = 0 ; i < k ; ++ i ) {
        for ( int j = 1 ; j <= tp ; ++ j ) {
            fl[ j ] = false ;
        }
        for ( auto x : spec[ i ] ) {
            fl[ rv[ get ( x ) ] ] = true ;
        }
        for ( int j = 1 ; j <= tp ; ++ j ) {
            if ( fl[ j ] == true ) {
                v[ i ].push_back ( j ) ;
            }
        }
    }
    vector < int > foo ( tp + 1 , -1 ) ;
    int ret = hopcroftKarp ( v , foo ) ;
    if ( ret == k ) { return true ; }
    return false ;
}

void solve ( ) {
    cin >> n >> m >> k ;
    for ( int i = 1 ; i <= m ; ++ i ) {
        cin >> hh[ i ].x >> hh[ i ].y >> hh[ i ].len ;
    }
    for ( int i = 0 ; i < k ; ++ i ) {
        int sz ; cin >> sz ;
        spec[ i ].resize ( sz ) ;
        for ( auto &x : spec[ i ] ) {
            cin >> x ;
        }
    }
    auto cmp = [ & ] ( edge p1 , edge p2 ) {
        return ( p1.len < p2.len ) ;
    };
    sort ( hh + 1 , hh + m + 1 , cmp ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        prv[ i ] = -1 ;
    }
    if ( can ( ) == false ) {
        cout << "-1\n" ;
        return ;
    }
    int ans = 0 , comps = n ;
    set < pii > bad ;
    for ( int i = 1 ; i <= m ; ++ i ) {
        for ( int j = 1 ; j <= n ; ++ j ) {
            rem[ j ] = prv[ j ] ;
        }
        if ( bad.find ( { get ( hh[ i ].x ) , get ( hh[ i ].y ) } ) != bad.end ( ) ) {
            continue ; 
        }
        if ( bad.find ( { get ( hh[ i ].y ) , get ( hh[ i ].x ) } ) != bad.end ( ) ) {
            continue ; 
        }
        if ( unite ( hh[ i ].x , hh[ i ].y ) == true ) { 
            if ( can ( ) == true ) {
                ans += hh[ i ].len ;
                -- comps ;
            }
            else {
                for ( int j = 1 ; j <= n ; ++ j ) {
                    prv[ j ] = rem[ j ] ;
                }
                bad.insert ( { get ( hh[ i ].x ) , get ( hh[ i ].y ) } ) ;
            }
        }
    }
    if ( comps != k ) {
        cout << "-1\n" ;
        return ;
    }
    cout << ans << "\n" ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; // cin >> t ;
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}