思路：

注意到答案有单调性，考虑二分答案。

现在由最优性问题转换为判定性问题。

我们很容易注意到一个性质：

  • 一个军队不停的往上跳是更优的。

  • 因为可以覆盖住更多的叶子节点。

那么对于二分答案的 \(mid\)，我们只需要求出每一个军队在 \(mid\) 时间内能跳到的最高的那个点，然后判定一下是否覆盖了所有叶子节点即可。

但是这样会存在一个问题，即若当前这个点为 \(1\) 的儿子，且有多个军队跳到，则可能可以支援一下 \(1\) 号点的其它儿子（因为检查点不能放在 \(1\) 上，则可能还有空余的时间经过 \(1\) 走到 \(1\) 的其它儿子）。

先来考虑一个简单的问题：

  • 若已知每个检查点的位置，如何判断是否覆盖了所有叶子节点；设 \(g_i\) 表示 \(i\) 处是否有检查点。

考虑先对于每个叶子节点标一个号（按照 dfn 序的大小），那么我们可以搜的时候预处理出 \(l_i,r_i\) 表示 \(i\) 这棵子树的叶子节点的编号为 \([l_i,r_i]\)。

则对于一个检查点 \(x\)，它可以覆盖 \([l_x,r_x]\) 这个范围，令这个区间都加 \(1\)，最后检验一下是否每个叶子节点都被加了至少一次，可以用差分实现。

但是这样就无法考虑支援问题，因为我们需要知道 \(1\) 号节点的每一个儿子所在子树的叶子节点是否全部都被覆盖。

考虑树形 dp，令 \(dp_u\) 表示点 \(u\) 所在子树的叶子节点是否都被覆盖了，则状态转移方程为：

\[dp_u = \begin{cases} 1 & g_u = 1 \\ \operatorname{and}\limits_{(u,v) \in E} dp_v & g_u = 0 \end{cases}
\]

若 \(1\) 号点的儿子 \(u\) 满足 \(dp_u=0\)，那么该点需要支援，将所有需要支援的点按照到 \(1\) 的距离排序。

则对于可以发动支援的点 \(v\)，设 \(v\) 到达 \(1\) 后还可以走 \(k\) 的距离（需要按 \(k\) 从小到大排序），那么我们可以贪心在需要支援的点集中找到距离 \(\le k\) 且距离最大的点，可以用 set 维护插入，删除，二分操作。

要注意一下细节，即若 \(v\) 不在 \(v\) 上设置检查点，也可以使得 \(dp_v=1\)，那么我们可以将 \(v\) 上的军队全部派出去支援；否则需要留一个军队守家，我们可以留剩下能走距离最小的那个军队守。

此时还会有一个问题别问我为什么贪心有这么多细节，即若这个点上的某一军队到不了任何一个需要支援的点且不需要守家，但是可以到一个需要留一个军队守家的点，且那个守家的军队可以走足够的距离去支援一个点，那么可以让这个点上的军队去代替它守家，这样会更优，称之为二次支援。

考虑在一次支援完后记录一下所有在守家且可以支援的点和所有无法支援却不需要守家的点。

那么二次支援和一次支援差不多，对于无法支援却不需要守家的点的点 \(u\)，设还可以走 \(k\) 的距离，那么我们可以在所有在守家且可以支援的点中找到距离 \(\le k\) 且距离最大的点，也可以用 set 维护。

然后再来考虑跳跃的问题：

  • 如何求出一个点在 \(mid\) 时间内能上跳到的最高的点。

很容易想到二分跳的次数然后长链剖分求 \(k\) 级祖先，这样是 \(\log^2 N\) 的，考虑优化。

考虑倍增与贪心，令 \(F_{i,j}\) 表示 \(i\) 的 \(2^j\) 级祖先，\(W_{i,j}\) 表示 \(i\) 到它的 \(2^j\) 级祖先的距离，状态转移方程为：

\[F_{i,j} = F_{F_{i,j-1},j-1}
\]

\[W_{i,j} = W_{i,j-1} + W_{F_{i,j-1},j-1}
\]

那么可以直接贪心从高位到低位枚举二级制位 \(i\)，若 \(W_{x,i} \le mid\)，则令 \(mid \gets mid - W_{x,i}\)，然后令 \(x\) 跳到 \(F_{x,i}\) 处；最后跳到不能再跳即可。

设 \(N,M\) 同阶，则总时间复杂度为 \(O(N \log N \log W)\)。

完整代码：

#include<bits/stdc++.h>
#define Add(x,y) (x+y>=mod)?(x+y-mod):(x+y)
#define lowbit(x) x&(-x)
#define pi pair<ll,ll>
#define pii pair<ll,pair<ll,ll>>
#define iip pair<pair<ll,ll>,ll>
#define ppii pair<pair<ll,ll>,pair<ll,ll>>
#define fi first
#define se second
#define full(l,r,x) for(auto it=l;it!=r;it++) (*it)=x
#define Full(a) memset(a,0,sizeof(a))
#define open(s1,s2) freopen(s1,"r",stdin),freopen(s2,"w",stdout);
using namespace std;
typedef double db;
typedef unsigned long long ull;
typedef long long ll;
bool Begin;
const ll N=5e4+10,M=16;
inline ll read(){
    ll x=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-')
          f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        x=(x<<1)+(x<<3)+(c^48);
        c=getchar();
    }
    return x*f;
}
inline void write(ll x){
	if(x<0){
		putchar('-');
		x=-x;
	}
	if(x>9)
	  write(x/10);
	putchar(x%10+'0');
}
ll n,m,x,t,l,r,ans=-1;
ll f[N],h[N],dp[N],DP[N];
ll F[N][M],W[N][M];
bool g[N];
vector<ll> T2;
vector<pi> T1;
vector<pi> E[N],G[N];
multiset<ll> S;
multiset<pi> T;
void add(ll u,ll v,ll w){
    E[u].push_back({v,w});
    E[v].push_back({u,w});
}
void dfs1(ll u,ll fa){
    ll son=0;
    if(u!=1){
        for(int i=1;i<M;i++){
            F[u][i]=F[F[u][i-1]][i-1];
            W[u][i]=W[u][i-1]+W[F[u][i-1]][i-1];
        }        
    }
    for(auto t:E[u]){
        ll v=t.fi,w=t.se;
        if(v==fa)
          continue;
        son++;
        if(u==1)
          F[v][0]=v;
        else{
            F[v][0]=u;
            W[v][0]=w;
        }
        dfs1(v,u);
    }
}
void dfs2(ll u,ll fa){
    if(g[u])
      dp[u]=1;
    for(auto t:E[u]){
        ll v=t.fi;
        if(v==fa)
          continue;
        dfs2(v,u);
        if(DP[u]==-1)
          DP[u]=dp[v];
        else
          DP[u]&=dp[v];
    }
    if(DP[u]==-1)
      DP[u]=0;
    if(dp[u]<1)
      dp[u]=DP[u];
}
bool check(ll mid){
    T1.clear(),T2.clear(),S.clear(),T.clear();
    for(int i=1;i<=n;i++){
        g[i]=h[i]=0;
        dp[i]=DP[i]=-1;
        G[i].clear();
    }
    for(int i=2;i<=n;i++){
        if(f[i]){
            x=i,t=mid;
            for(int j=M-1;j>=0;j--){
                if(W[x][j]<=t){
                    t-=W[x][j];
                    x=F[x][j];
                }
            }
            g[x]=1;
            h[x]+=f[i];
            G[x].push_back({t,f[i]});
        }
    }
    dfs2(1,1);
    for(auto t:E[1]){
        ll v=t.fi,w=t.se;
        DP[v]^=1ll;
        if(dp[v])
          continue;
        S.insert(w);
    }
    for(auto t:E[1]){
        bool F=1;
        ll v=t.fi,w=t.se;
        if(!dp[v])
          continue;
        sort(G[v].begin(),G[v].end());
        for(auto p:G[v]){
            ll d=p.fi-w,s=p.se;
            if(F&&DP[v]){
              s--;
              T1.push_back({w,d});
              F=0;
            }
            while(s&&!S.empty()){
                auto it=S.upper_bound(d);
                if(it!=S.begin()){
                    it--;
                    S.erase(it);
                }
                else
                  T2.push_back(d);
                s--;
                h[v]--;
            }
        }
        if(S.empty())
          break;
    }
    if(S.empty())
      return 1;
    else{
        for(auto t:T1)
          if(S.upper_bound(t.se)!=S.begin())
            T.insert(t);
        for(auto v:T2){
            auto it=T.upper_bound({v,1e18});
            if(it!=T.begin()){
                it--;
                t=(*it).se;
                T.erase(it);
                auto it=S.upper_bound(t);
                if(it!=S.begin()){
                    it--;
                    S.erase(it);
                }
            }
        }
        if(S.empty())
          return 1;
        return 0;
    }
}
bool End;
int main(){
    n=read();
    for(int u,v,w,i=1;i<n;i++){
        u=read(),v=read(),w=read();
        add(u,v,w);
    }
    m=read();
    while(m--){
        x=read();
        f[x]++;
    }
    dfs1(1,1);
    l=0,r=5e13;
    while(l<=r){
        ll mid=(l+r)>>1;
        if(check(mid)){
            ans=mid;
            r=mid-1;
        }
        else
          l=mid+1;
    }
    write(ans);
//	cerr<<'\n'<<abs(&Begin-&End)/1048576<<"MB";
	return 0;
}