#include <iostream>
#include <vector>
#include <queue>
#include <bitset>

using namespace std;

#define Par pair<ll, ll>
#define ll long long
#define TB(n, bit) (n |= (1 << bit))
#define INF (1LL << 60)

class Tripla
{
public:
    int costo, nodo, bit;
    Tripla(int _costo, int _nodo, int _bit);
};

Tripla::Tripla(int _costo, int _nodo, int _bit)
{
    costo = _costo;
    nodo = _nodo;
    bit = _bit;
}

bool operator<(const Tripla &a, const Tripla &b)
{
    return a.costo > b.costo;
}

struct Grafo
{
    vector <vector <Par> > adj;
    vector <vector <ll> > d;
    vector <ll> fish;
    int n, m, k;

    void Dijkstra()
    {
        priority_queue<Tripla> pq;

        d[fish[1]][1] = 0;
        pq.push(Tripla(0, 1, fish[1]));

        while(pq.size())
        {
            Tripla t = pq.top();
            pq.pop();

            for(int i=0; i<adj[t.nodo].size(); i++)
            {
                int vecino = adj[t.nodo][i].second;
                int bit = t.bit | fish[vecino];
                int dist = t.costo + adj[t.nodo][i].first;

                if(d[bit][vecino] > dist)
                {
                    d[bit][vecino] = dist;
                    pq.push(Tripla(dist, vecino, bit));
                }
            }
        }

        ll target = (1 << k)-1;
        ll resultado = INF;

        for(int i=0; i<d.size(); i++)
        {
            for(int j=i; j<d.size(); j++)
            {
                ll combinado = i | j;
                ll dist = max(d[i][n], d[j][n]);

                if(combinado == target)
                    resultado = min(resultado, dist);
            }
        }

        cout << resultado << endl;
    }

    void leer()
    {
        cin >> n >> m >> k;

        adj.resize(n+1);
        d = vector <vector <ll> > ((1 << k)+1, vector <ll> (n+1, INF));
        fish = vector <ll> (n+1, 0);

        for(int i=0; i<n; i++)
        {
            int cant, id;
            cin >> cant;
            for(int j=0; j<cant; j++)
            {
                cin >> id;
                TB(fish[i+1], id-1);
            }
        }

        for(int i=0; i<m; i++)
        {
            int desde, hacia, costo;
            cin >> desde >> hacia >> costo;
            adj[desde].push_back({costo, hacia});
            adj[hacia].push_back({costo, desde});
        }

        Dijkstra();
    }

};

int main()
{
    Grafo g;
    g.leer();

    return 0;
}