#include <stdio.h>

#include <string.h>

#include <iostream>

#include <queue>

#include <vector>

using namespace std ;

struct node

{

    int u,w ;

}temp ;

struct BFS

{

    int u,w,step ;

}t,t1 ;

const int maxn =  ;

const int INF =  ;

vector<node> vec[maxn] ;

queue<BFS>Q ;

bool hashh[],vis[maxn] ;

int n,m,h ;

int ret[maxn],st[maxn] ;

void DFS(int u,int w,int step)

{

    if(vis[u]) return  ;

    if(w >= ret[u]) return ;

    if(w > ) ret[u] = w ;

    if(hashh[u] && w == ) vis[u] = true ;

    for(int i =  ; i < vec[u].size() ; i++)

    {

        if(hashh[vec[u][i].u] && (!vis[vec[u][i].u]) && (w+vec[u][i].w<=) && (step +  < st[vec[u][i].u]))

        {

            t.u = vec[u][i].u ;

            //t.w = vec[u][i].w ;

            t.step = step+ ;

            st[t.u] = t.step ;

            Q.push(t) ;

        }

        if(w+vec[u][i].w <= )

            DFS(vec[u][i].u,w+vec[u][i].w,step) ;

    }

}

void BFS()

{

    while(!Q.empty())

        Q.pop() ;

    t.u =  ;

    t.w = t.step =  ;

    Q.push(t) ;

    while(!Q.empty())

    {

        t1 = Q.front() ;

        Q.pop() ;

        if(t1.u == n)

        {

            printf("%d\n",t1.step-) ;

            return ;

        }

        DFS(t1.u,,t1.step) ;

    }

    printf("-1\n") ;

    return ;

}

int main()

{

    while(~scanf("%d",&n))

    {

        if(n == ) break ;

        for(int i =  ; i <= n ; i++)

        {

            vector<node>().swap(vec[i]) ;

            ret[i] = st[i] = INF ;

            hashh[i] = vis[i] = false ;

        }

        hashh[] = hashh[n] = true ;

        scanf("%d",&m) ;

        int s ;

        for(int i =  ; i < m ; i++)

        {

            scanf("%d",&s) ;

            hashh[s] = true ;

        }

        scanf("%d",&h) ;

        int u,v,w ;

        for(int i =  ; i < h ; i++)

        {

            scanf("%d %d %d",&u,&v,&w) ;

            temp.u = v ;

            temp.w = w ;

            vec[u].push_back(temp) ;

            temp.u = u ;

            vec[v].push_back(temp) ;

        }

        BFS() ;

    }

    return  ;

}

#include <cstdio>

#include <cstring>

#include <map>

#include <vector>

#include <queue>

#define maxn 200

#include <algorithm>

using namespace std;

const int inf=0x3fffffff;

struct node

{

    int v,cost;

};

int g[maxn][maxn],a[maxn],dis[];

int n,m,k;

map<int,int>q;

vector<node>v[];

bool vis[];

int que[];

void inti()

{

    q.clear();

    for(int i=; i<=n; i++)

    {

        v.clear();

    }

    for(int i=; i<=m+; i++)

    {

        for(int j=; j<=m+; j++)

        {

            g[j]=inf;

            if(i==j) g[j]=;

        }

    }

}

void spfa(int qr)

{

    queue<int>qq;

    memset(vis,false,sizeof(vis));

    for(int i=; i<=n; i++) dis=inf;

    dis[qr]=;

    qq.push(qr);

    vis[qr]=true;

    while(!qq.empty())

    {

        int x=qq.front();

        qq.pop();

        vis[x]=false;

        for(int i=; i<(int)v[x].size(); i++)

        {

            int v2=v[x].v,cost=v[x].cost;

            if(dis[v2]>dis[x]+cost)

            {

                dis[v2]=dis[x]+cost;

                if(!vis[v2])

                {

                    vis[v2]=true;

                    qq.push(v2);

                }

            }

        }

    }

    for(int i=; i<=n; i++)

    {

        if(dis<=&&q!=)

        {

            g[q[qr]][q]=;

        }

    }

}

void floyd()

{

    for(int c=; c<=m+; c++)

    {

        for(int i=; i<=m+; i++)

        {

            for(int j=; j<=m+; j++)

            {

                    g[j]=min(g[j],g[c]+g[c][j]);

            }

        }

    }

}

int main()

{

    while(scanf("%d",&n)!=EOF)

    {

        if(n==) break;

        scanf("%d",&m);

        inti();

        for(int i=; i<=m; i++)

        {

            scanf("%d",&a);

            q[a]=i;

        }

        a[]=;

        q[]=;

        a[m+]=n;

        q[n]=m+;

        scanf("%d",&k);

        for(int i=; i<k; i++)

        {

            int u,v1,cost;

            scanf("%d%d%d",&u,&v1,&cost);

            node st;

            st.v=v1;

            st.cost=cost;

            node st1;

            st1.v=u;

            st1.cost=cost;

            v.push_back(st);

            v[v1].push_back(st1);

        }

        for(int i=; i<=m; i++)

        {

            spfa(a);

        }

        floyd();

        if(g[][m+]==inf)

        {

            printf("-1\n");

        }

        else

            printf("%d\n",g[][m+]-);

    }

    return ;

}