#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

const int MAX_V = 100;
const int INF = 1000000000;

int gcd(int a, int b)
{
    while( 1 )
    {
        a = a % b;
        if( a == 0 )
            return b;
        b = b % a;

        if( b == 0 )
            return a;
    }
}

void dijkstra(vector<pair<int,int> > * adj,
        vector<int>* parent, 
        int v, 
        int src) {
    vector<int> dist(v, INF);

    dist[src] = 0;
    priority_queue<pair<int, int> > pq;
    pq.push(make_pair(0, src));

    while ( !pq.empty() ) {
        int cost = -pq.top().first;
        int here = pq.top().second;
        pq.pop();

        if ( dist[here] < cost ) continue;

        for ( int i =0 ; i < adj[here].size(); ++i){
            int there = adj[here][i].first;
            int nextDist = cost + adj[here][i].second;

            if ( dist[there] > nextDist) {
                parent[there].clear();
                parent[there].push_back(here);

                dist[there] = nextDist;
                pq.push(make_pair(-nextDist, there));
            }
            else if ( dist[there] == nextDist ) {
                parent[there].push_back(here);
            }
        }
    }
}


vector<vector<int> > getAllPath(vector<int> *parent, int v)
{
    if ( v == 0 )
    {
        vector<vector<int> > allPath;
        vector<int> path;
        path.push_back(0);
        allPath.push_back(path);
        return allPath;
    }

    vector<vector<int> > allPath;
    for ( int i = 0; i < parent[v].size(); i++ )
    {
        vector<vector<int> > paths = getAllPath(parent, parent[v][i]);
        for ( int j = 0; j < paths.size(); j++ )
        {
            paths[j].push_back(v);
            allPath.push_back(paths[j]);
        }
    }

    return allPath;
}

int main()
{
    int C;
    scanf("%d", &C);

    while ( C-- ) {
        int N;
        int v, e;

        int start, end, cost;
        int point;

        vector<pair<int,int> > adj[MAX_V];
        vector<int> parent[MAX_V];

        scanf("%d %d %d", &v, &e, &N);
        for ( int i = 0; i < e; i++ ) {
            scanf("%d %d %d", &start, &end, &cost);
            adj[start-1].push_back(make_pair(end-1,cost));
        }

        dijkstra( adj, parent, v, 0);

        vector<vector<int> > allPath = getAllPath(parent, v-1);

        vector<int> p(v,0);

        for ( int i = 0; i < allPath.size(); i++ )
        {
            printf("%d : ",i);
            for ( int j = 0; j < allPath[i].size(); j++ )
            {
                printf("%d ", allPath[i][j]+1);
                p[allPath[i][j]]++;
            }
            printf("\n");
        }

        for ( int i = 0; i < N; i++ )
        {
            int n;
            scanf("%d", &n);
            if ( p[n-1] == 0 )
                printf("0/1\n");
            else
            {

                int x = gcd(allPath.size(), p[n-1]);
                printf("%d/%d\n", p[n-1]/x, (int)allPath.size() / x);
            }
        }
    }

    return 0;
}