#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
#include <map>
using namespace std;

namespace solve
{
    const int maxn = 5e5 + 10;
    typedef long long ll;
    const ll inf = 1e18;

    vector<pair<int, int>> e[maxn];
    inline void add(int x, int y, int w) { e[x].emplace_back(y, w); }

    int n, m, k;

    map<int, int> ch[maxn];
    int ed[maxn], tot = 1;

    void insert(vector<int> a)
    {
        int p = 1;
        for (int i = 0; i < (int)a.size(); i++)
        {
            int c = a[i];
            if (!ch[p][c])
                ch[p][c] = ++tot;
            p = ch[p][c];
        }
        ed[p] = 1;
    }

    int root[maxn];
    int used[maxn];

    struct tree
    {
        static const int maxn = solve::maxn << 5;

        int ls[maxn], rs[maxn], tot, vis[maxn];
        int adj[maxn], v[maxn], w[maxn];
        tree() { memset(w, 0x3f, sizeof(w)); }
        void clone(int &k)
        {
            tot++, ls[tot] = ls[k], rs[tot] = rs[k], adj[tot] = adj[k], v[tot] = v[k], w[tot] = w[k];
            k = tot;
        }
        void modify(int l, int r, int x, int v, int &k)
        {
            clone(k);
            if (l == r)
            {
                adj[k] = v;
                return;
            }
            int mid = (l + r) / 2;
            if (x <= mid)
                modify(l, mid, x, v, ls[k]);
            else
                modify(mid + 1, r, x, v, rs[k]);
        }
        void modify2(int l, int r, int x, int vv, int ww, int &k)
        {
            clone(k);
            if (l == r)
            {
                v[k] = vv, w[k] = ww;
                return;
            }
            int mid = (l + r) / 2;
            if (x <= mid)
                modify2(l, mid, x, vv, ww, ls[k]);
            else
                modify2(mid + 1, r, x, vv, ww, rs[k]);
        }
        void get(int l, int r, int k)
        {
            if (vis[k] || !k)
                return;
            vis[k] = 1;
            if (l == r)
            {
                if (!used[adj[k]] && !ed[adj[k]])
                    b.emplace_back(adj[k], w[k]);
                return;
            }
            int mid = (l + r) / 2;
            get(l, mid, ls[k]), get(mid + 1, r, rs[k]);
        }
        int query(int l, int r, int x, int k)
        {
            if (l == r)
                return adj[k];
            int mid = (l + r) / 2;
            if (x <= mid)
                return query(l, mid, x, ls[k]);
            else
                return query(mid + 1, r, x, rs[k]);
        }
        void dfs(int l, int r, int k)
        {
            if (!k)
                return;
            if (l == r)
            {
                cerr << "?" << l << " " << adj[k]  << " " << w[k] << endl;
                return;
            }
            int mid = (l + r) / 2;
            dfs(l, mid, ls[k]), dfs(mid + 1, r, rs[k]);
        }
        vector<pair<int, int>> b;
        vector<pair<int, int>> get(int x)
        {
            b.clear();
            get(1, n, root[x]);
            return b;
        }
    } t;

    int fail[maxn];

    void build()
    {
        queue<int> q;
        q.push(1);
        for (auto o : ch[1])
            t.modify(1, n, o.first, o.second, root[1]);
        while (!q.empty())
        {
            int x = q.front();
            q.pop();
            root[x] = root[fail[x]];
            if (x >= 2 && x <= n + 1)
                for (auto [v, w] : e[x - 1])
                    t.modify2(1, n, v, v, w, root[x]);
            for (auto o : ch[x])
            {
                fail[o.second] = t.query(1, n, o.first, root[x]);
                ed[o.second] |= ed[fail[o.second]];
                t.modify(1, n, o.first, o.second, root[x]);
                q.push(o.second);
            }
        }
        /*
        for (int i = 1; i <= tot; i++)
        {
            cerr << i << " " << fail[i] << " " << ed[i] << endl;
            t.dfs(1, n, root[i]);
        }
        */
    }

    ll dis[maxn];
    int vis[maxn];
    
    void dij()
    {
        priority_queue<pair<ll, int>> q;
        for (int i = 1; i <= tot; i++)
            dis[i] = inf;
        dis[2] = 0, q.push({0, 2});
        while (!q.empty())
        {
            auto o = q.top();
            q.pop();
            if (used[o.second] || ed[o.second])
                continue;
            used[o.second] = 1;
            int x = o.second;
            auto e = t.get(x);
            for (auto [v, w] : e)
            {
                if (dis[x] + w < dis[v])
                    dis[v] = dis[x] + w, q.push({-dis[v], v});
            }
        }
        /*
        for (int i = 1; i <= tot; i++)
            cerr << dis[i] << " ";
        cerr << endl;
        */
    }

    void main()
    {
        cin >> n >> m >> k;
        for (int i = 0, x, y, w; i < m; i++)
            cin >> x >> y >> w, add(x, y, w);
        for (int i = 1; i <= n; i++)
            ch[1][i] = ++tot, ch[0][i] = 1;
        for (auto o : ch[0])
            t.modify(1, n, o.first, o.second, root[0]);
        for (int i = 0; i < k; i++)
        {
            vector<int> qwq;
            int u;
            cin >> u;
            for (int i = 0, x; i < u; i++)
                cin >> x, qwq.push_back(x);
            insert(qwq);
        }
        // cerr << "?" << tot << endl;
        build();
        dij();
        cout << (dis[n + 1] == inf ? -1ll : dis[n + 1]) << endl;
    }
}

int main()
{
    ios::sync_with_stdio(false), cin.tie(0);
    int T = 1;
    // cin >> T;
    while (T--)
        solve::main();
}