#include<algorithm>

 #include<fstream>

 #include<functional>

 #include<iostream>

 using namespace std;

 static const int N=;

 typedef long long int64;

 struct node

 {

     int v,w;

     node *next;

 }alist[*N];

 struct heapnode

 {

     int64 w;

     int u;

     bool operator>(const heapnode &r)const

     {

         return w>r.w;

     }

 };

 int p[N][];

 int64 w[N][];

 void dfs1(int u)

 {

     for(node *i=alist[u].next;i;i=i->next)

         if(i->v!=p[u][])

         {

             p[i->v][]=u;

             w[i->v][]=i->w;

             dfs1(i->v);

         }

 }

 bool visit[N];

 void dfs2(int u)

 {

     if(visit[u])return;

     if(!alist[u].next->next)return;

     visit[u]=true;

     for(node *i=alist[u].next;i;i=i->next)

         if(i->v!=p[u][])

         {

             dfs2(i->v);

             if(!visit[i->v])

             {

                 visit[u]=false;

                 break;

             }

         }

 }

 int main()

 {

     ifstream fin("blockade.in");

     ofstream fout("blockade.out");

     int n(),m();

     fin>>n;

     node *anode(alist+n+);

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

     {

         int u(),v(),ww();

         fin>>u>>v>>ww;

         anode->v=v;

         anode->w=ww;

         anode->next=alist[u].next;

         alist[u].next=anode++;

         anode->v=u;

         anode->w=ww;

         anode->next=alist[v].next;

         alist[v].next=anode++;

     }

     fin>>m;

     static int d[N];

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

         fin>>d[i];

     int NScount=;

     for(node *i=alist[].next;i;i=i->next)

     {

         NScount++;

         p[i->v][]=;

         w[i->v][]=i->w;

         dfs1(i->v);

     }

     if(NScount>m)

     {

         fout<<"-1"<<endl;

         return ;

     }

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

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

         {

             p[i][j]=p[p[i][j-]][j-];

             w[i][j]=w[i][j-]+w[p[i][j-]][j-];

         }

     static heapnode a[N],b[N];

     heapnode *atop(),*aback(),*btop(),*bback();

     static int _w[N];

     for(node *i=alist[].next;i;i=i->next)

         _w[i->v]=i->w;

     int64 l(),r(1e16),ans(1e16);

     greater<heapnode> comp;

     while(l<=r)

     {

         atop=a;

         aback=a;

         btop=b;

         bback=b;

         int64 mm=(l+r)>>;

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

             visit[i]=false;

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

         {

             int u=d[i];

             int64 ww=mm;

             for(int j=;j>=;j--)

                 if(p[u][j]&&p[u][j]!=&&ww>=w[u][j])

                 {

                     ww-=w[u][j];

                     u=p[u][j];

                 }

             if(/*p[u][0]==1&&*/ww>w[u][])

             {

                 aback->w=ww-w[u][];

                 aback->u=u;

                 aback++;

                 push_heap(atop,aback,comp);

             }

             else visit[u]=true;

         }

         dfs2();

         if(visit[])

         {

             ans=mm;

             r=mm-;

         }

         else

         {

             for(node *i=alist[].next;i;i=i->next)

                 if(!visit[i->v])

                 {

                     bback->w=i->w;

                     bback->u=i->v;

                     bback++;

                     push_heap(btop,bback,comp);

                 }

             while(btop!=bback||atop!=aback)

             {

                 while(atop!=aback&&!visit[atop->u]&&atop->w<_w[atop->u])

                 {

                     visit[atop->u]=true;

                     pop_heap(atop,aback,comp);

                     aback--;

                 }

                 while(btop!=bback&&visit[btop->u])

                 {

                     pop_heap(btop,bback,comp);

                     bback--;

                 }

                 if(btop==bback||atop==aback)break;

                 if(atop->w>=btop->w)

                 {

                     visit[btop->u]=true;

                     pop_heap(atop,aback,comp);

                     aback--;

                     pop_heap(btop,bback,comp);

                     bback--;

                 }

                 else

                 {

                     pop_heap(atop,aback,comp);

                     aback--;

                 }

             }

             if(btop==bback)

             {

                 ans=min(ans,mm);

                 r=mm-;

             }

             else l=mm+;

         }

     }

     fout<<ans<<endl;

     return ;

 }