#include <bits/stdc++.h>
#include <chrono>
#include <random>
#define endl '\n'
#define fi first
#define se second

using namespace std;

const double TIME_LIMIT = 4.800;
chrono::time_point<chrono::steady_clock> tmr_begin;
void initClock()
{
    tmr_begin = chrono::steady_clock::now();
}
double getTime()
{
    return 1e-3 * chrono::duration_cast<chrono::milliseconds>(chrono::steady_clock::now() - tmr_begin).count();
}
void fileInOut()
{
    freopen("transport.in", "r", stdin);
    freopen("transport.out", "w", stdout);
}
void fastIO()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}

const int MAXN = 205;
const int MAXG = 1005;
const int MAXM = 1005;
const int T=2000;
const int INF = 1e9 + 5;
const long long INFLL = (long long)1e18 + 5;

mt19937 mt(666);

struct Route
{
    int t;
    vector<int> kids;
    //vector<int> path;
    int dest;

    /*Route()
    {
        t=0;
        kids=vector<int>();
        dest=0;
    }*/
};

int n,m,g;
vector<pair<int,int> > adj[MAXN];
int twn[MAXG];
vector<int> kids[MAXN];
pair<int,int> cost[MAXN][2005];

priority_queue<pair<int,int> > pq;
bool used[MAXN];
int dist[MAXN];
int par[MAXN];

vector<int> perm;
vector<Route> routes;
bool usedT[2005];
long long bestCost=INFLL;
vector<int> bestPerm;

void dijkstra(int s)
{
    for(int i=1;i<=n;i++) used[i]=0;
    for(int i=1;i<=n;i++) dist[i]=INF;
    dist[s]=0;
    par[s]=-1;
    pq.push({0,s});
    while(!pq.empty())
    {
        int v=pq.top().se;
        pq.pop();
        if(used[v]) continue;
        used[v]=1;
        for(auto [u,w]: adj[v])
        {
            if(!used[u] && dist[v]+w<dist[u])
            {
                dist[u]=dist[v]+w;
                par[u]=v;
                pq.push({-dist[u],u});
            }
        }
    }
}

void initTry()
{
    shuffle(perm.begin(), perm.end(), mt);
    // for(int i=0;i<n-1;i++)
    // {
    //     if(perm[i]==1)
    //     {
    //         swap(perm[i], perm[n-1]);
    //         break;
    //     }
    // }
    for(int i=0;i<=T;i++) usedT[i]=0;
}

void calcCost()
{
    long long curCost=0;
    for(int i=0;i<n;i++)
    {
        int town=perm[i];
        int cnt=kids[town].size();
        int ptr=1;
        while(cnt>0)
        {
            int cur=min(cnt, 4);
            cnt-=cur;
            while(usedT[cost[town][ptr].se]) ptr++;
            usedT[cost[town][ptr].se]=1;
            curCost+=1LL*dist[town]*(cur)*cost[town][ptr].fi;
        }
    }
    if(curCost<bestCost)
    {
        bestCost=curCost;
        bestPerm=perm;
    }
}

void getRoutes()
{
    for(int i=0;i<=T;i++) usedT[i]=0;
    routes.clear();
    for(int i=0;i<n;i++)
    {
        int town=bestPerm[i];
        vector<int> tmp=kids[town];
        int ptr=1;
        while(!tmp.empty())
        {
            routes.push_back(Route());
            routes.back().dest=town;
            int sz=tmp.size();
            for(int j=0;j<min(4,sz);j++)
            {
                routes.back().kids.push_back(tmp.back());
                tmp.pop_back();
            }
            while(usedT[cost[town][ptr].se]) ptr++;
            usedT[cost[town][ptr].se]=1;
            routes.back().t=cost[town][ptr].se;
        }
    }
}

bool cmp(Route a,Route b)
{
    return a.t<b.t;
}

void printSol()
{
    sort(routes.begin(), routes.end(), cmp);
    cout<<routes.size()<<endl;
    for(auto cur: routes)
    {
        cout<<cur.t<<" "<<cur.kids.size()<<" ";
        vector<int> path;
        int v=cur.dest;
        do
        {
            path.push_back(v);
            v=par[v];
        }while(v!=-1);
        reverse(path.begin(), path.end());
        cout<<path.size()<<endl;
        for(auto x: cur.kids) cout<<x<<" ";
        cout<<endl;
        for(auto x: path) cout<<x<<" ";
        cout<<endl;
    }
}

int main()
{
    fastIO();
    fileInOut();
    initClock();

    cin>>n>>m>>g;
    for(int i=1;i<=g;i++) cin>>twn[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=T;j++) 
        {
            cin>>cost[i][j].fi;
            cost[i][j].se=j;
        }
    }
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        adj[u].push_back({v,w});
        adj[v].push_back({u,w});
    }

    dijkstra(1);
    
    for(int i=1;i<=g;i++)
    {
        kids[twn[i]].push_back(i);
    }

    perm.resize(n);
    iota(perm.begin(), perm.end(), 1);
    for(int i=1;i<=n;i++)
    {
        sort(cost[i]+1, cost[i]+T+1);
    }

    for(;getTime()<TIME_LIMIT;)
    {
        initTry();
        calcCost();
    }
    getRoutes();
    
    printSol();
    
    return 0;
}