#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <limits>
#include <algorithm>

using namespace std;

const int MAX_N = 105;
const int MAX_T = 2005;
const int INF = numeric_limits<int>::max();

struct Edge {
    int to;
    int weight;
};

struct Child {
    int id;
    int home_city;
    bool delivered = false;
};

int N, M, G;
vector<Child> children;
vector<int> home_city;
vector<vector<Edge>> adj;
int cost[MAX_N][MAX_T]; 

void dijkstra(int start, vector<int>& dist) {
    dist.assign(N + 1, INF);
    dist[start] = 0;

    using State = pair<int, int>; 
    priority_queue<State, vector<State>, greater<State>> pq;
    pq.push(make_pair(0, start));

    while (!pq.empty()) {
        State top = pq.top();
        pq.pop();
        int cur_dist = top.first;
        int u = top.second;

        if (cur_dist > dist[u]) continue;

        for (const Edge& e : adj[u]) {
            int v = e.to;
            int w = e.weight;
            if (dist[v] > cur_dist + w) {
                dist[v] = cur_dist + w;
                pq.push(make_pair(dist[v], v));
            }
        }
    }
}

int main() {
    ifstream fin("transport.in");
    ofstream fout("transport.out");

 
    fin >> N >> M >> G;

    home_city.resize(G);
    children.reserve(G);
    for (int i = 0; i < G; i++) {
        fin >> home_city[i];
        children.push_back({ i, home_city[i] });
    }

 
    for (int i = 1; i <= N; i++) {
        for (int t = 1; t <= 2000; t++) {
            fin >> cost[i][t];
        }
    }

    adj.resize(N + 1);
    for (int i = 0; i < M; i++) {
        int u, v, w;
        fin >> u >> v >> w;
        adj[u].push_back({ v, w });
        adj[v].push_back({ u, w });
    }

    vector<int> dist_from_start;
    dijkstra(1, dist_from_start);

  
    fout << 0 << endl;

    fin.close();
    fout.close();
    return 0;
}