#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>

#include <map>
#include <queue>

const long long INF = 1e18;

const int N = 2e5;

int n, m, k, cnt, cnt2;

std::vector<std::pair<int, int> > adj[N + 5];

int Root[N * 2 + 5];

struct node {
	int ls, rs, to, dis;
} tree[N * 2 * 20 + 5];

void upd(int &u, int L, int R, int pos, int to, int dis = -1) {
	tree[++cnt2] = tree[u]; u = cnt2;
	if (L == R) {
		tree[u].to = to;
		if (dis != -1) {
			tree[u].dis = dis;
		}
		return ;
	}
	int mid = (L + R) >> 1;
	if (pos <= mid) {
		upd(tree[u].ls, L, mid, pos, to, dis);
	} else {
		upd(tree[u].rs, mid + 1, R, pos, to, dis);
	}
}

std::pair<int, int> ask(int u, int L, int R, int pos) {
	if (u == 0) {
		return {-1, -1};
	} else if (L == R) {
		return {tree[u].to, tree[u].dis};
	}
	int mid = (L + R) >> 1;
	if (pos <= mid) {
		return ask(tree[u].ls, L, mid, pos);
	} else {
		return ask(tree[u].rs, mid + 1, R, pos);
	}
}

std::map<int, int> trans[N * 2 + 5];

int id[N * 2 + 5];
int end[N * 2 + 5];
int fail[N * 2 + 5];

void ins(const std::vector<int> &v) {
	int u = 0;
	for (int i = 0; i < (int)v.size(); i++) {
		if (trans[u].count(v[i])) {
			u = trans[u][v[i]];
		} else {
			u = trans[u][v[i]] = ++cnt;
			id[cnt] = v[i];
		}
	}
	end[u]++;
}

void build() {
	std::queue<int> q;
	for (int i = 1; i <= n; i++) {
		q.push(fail[i] = i);
		for (const auto &e : adj[i])
			upd(Root[i], 1, n, e.first, e.first, e.second);
	}
	while (!q.empty()) {
		int u = q.front(); q.pop();
		Root[u] = Root[fail[u]];
		for (const auto &e : trans[u]) {
			fail[e.second] = ask(Root[u], 1, n, e.first).first;
			if (fail[e.second] != -1) {
				upd(Root[u], 1, n, e.first, e.second);
				q.push(e.second);
			}
		}
	}
}

long long dis[N * 2 + 5];
bool vis[N * 2 + 5];

std::priority_queue<std::pair<long long, int> > q;

void dfs(int &u, int L, int R, int from) {
	if (u != 0) {
		if (L == R) {
			int to = tree[u].to, dist = tree[u].dis;
			if (!end[to] && dis[from] + dist < dis[to]) {
				dis[to] = dis[from] + dist;
				q.push({-dis[to], to});
			}
		} else {
			int mid = (L + R) >> 1;
			dfs(tree[u].ls, L, mid, from);
			dfs(tree[u].rs, mid + 1, R, from);
		}
	}
	u = 0;
}

long long dijkstra(int start) {
	if (end[start]) {
		return -1;
	}
	for (int i = 1; i <= cnt; i++)
		dis[i] = INF;
	q.push({0LL, start});
	dis[start] = 0;
	while (!q.empty()) {
		int u = q.top().second; q.pop();
		if (id[u] == n) return dis[u];
		else if (vis[u]) continue;
		vis[u] = true;
		dfs(Root[u], 1, n, u);
	}
	return -1;
}

void solve() {
	std::cin >> n >> m >> k;
	for (int i = 1, u, v, w; i <= m; i++) {
		std::cin >> u >> v >> w;
		adj[u].push_back({v, w});
	}
	for (int i = 1; i <= n; i++) {
		trans[0][i] = ++cnt;
		id[cnt] = i;
	}
	while (k--) {
		int Len;
		std::cin >> Len;
		std::vector<int> v(Len);
		for (int i = 0; i < Len; i++)
			std::cin >> v[i];
		ins(v);
	}
	build();
	long long ans = dijkstra(1);
	std::cout << ans << "\n";
}

int main() {
	#ifdef ONLINE_JUDGE
		freopen("path.in", "r", stdin);
		freopen("path.out", "w", stdout);
	#endif
	
	std::ios::sync_with_stdio(false);
	
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	std::cerr.tie(nullptr);
	
	int t = 1;
//	std::cin >> t;
	
	while (t--) {
		solve();
	}
	
	return 0;
}