BaoBao has just found a rooted tree with n vertices and (n-1) weighted edges in his backyard. Among the vertices, of them are red, while the others are black. The root of the tree is vertex 1 and it's a red vertex.
Let's define the cost of a red vertex to be 0, and the cost of a black vertex to be the distance between this vertex and its nearest red ancestor.

Recall that

• The length of a path on the tree is the sum of the weights of the edges in this path.

• The distance between two vertices is the length of the shortest path on the tree to go from one vertex to the other.

• Vertex is the ancestor of vertex v  if it lies on the shortest path between vertex and the root of the tree (which is vertex 1 in this problem).

As BaoBao is bored, he decides to play q games with the tree. For the i-th game, BaoBao will select k_i vertices v_1,1,v_i,2,...,v_i,ki on the tree and try to minimize the maximum cost of these k_i vertices by changing at most one vertex on the tree to a red vertex.

Note that

• BaoBao is free to change any n vertex among all the vertices to a red vertex, NOT necessary among the k_i  vertiecs whose maximum cost he tries to minimize.

• All the q games are independent. That is to say, the tree BaoBao plays with in each game is always the initial given tree, NOT the tree modified during the last game by changing at most one vertex.

Please help BaoBao calculate the smallest possible maximum cost of the given k_i vertices in each game after changing at most one vertex to a red vertex.

Input

There are multiple test cases. The first line of the input is an integer T, indicating the number of test cases. For each test case:

The first line contains three integers n,m and q (2≤m≤n≤10⁵,1≤q≤2×10⁵), indicating the size of the tree, the number of red vertices and the number of games.

The second line contains m  integers r₁,r₂,...,r_m (1=r₁<r₂<...<r_m≤n), indicating the red vertices.

The following (n-1)  lines each contains three integers u_i,v_i and w_i (1≤u_i,v_i≤n,1≤w_i≤10⁹ ), indicating an edge with wi weight connecting vertex ui and vi  in the tree.

For the following q  lines, the i-th line will first contain an integer k_i(1≤k_i≤n). Then k_i  integers v_i,1,v_i,2,...v_iki  follow (1≤v_i,1<v_i,2<...<v_iki≤n), indicating the vertices whose maximum cost BaoBao has to minimize.

It's guaranteed that the sum of in all test cases will not exceed , and the sum of in all test cases will not exceed .

Output

For each test case output q  lines each containing one integer, indicating the smallest possible maximum cost of the k_i vertices given in each game after changing at most one vertex in the tree to a red vertex.

Sample Input

2

12 2 4

1 9

1 2 1

2 3 4

3 4 3

3 5 2

2 6 2

6 7 1

6 8 2

2 9 5

9 10 2

9 11 3

1 12 10

3 3 7 8

4 4 5 7 8

4 7 8 10 11

3 4 5 12

3 2 3

1 2

1 2 1

1 3 1

1 1

2 1 2

3 1 2 3

Sample Output

4

5

3

8

0

0

0

Hint

The first sample test case is shown above. Let's denote C(v) as the cost of vertex v .

For the 1st game, the best choice is to make vertex 2 red, so that C(3)=4,C(7)=3 and C(8)=4. So the answer is 4.

For the 2nd game, the best choice is to make vertex 3 red, so that C(4)=3,C(5)=2,C(7)=4 and C(8)=5. So the answer is 5.

For the 3rd game, the best choice is to make vertex 6 red, so that C(7)=1,C(8)=2,C(10)=2 and C(11)=3. So the answer is 3.

For the 4th game, the best choice is to make vertex 12 red, so that C(4)=8,C(5)=7 and C(12)=0. So the answer is 8.

Due to the design restrictions of ZOJ, we can only provide a subset of the testing data here (the original data is too large for ZOJ to store). We will update the testing data once we update ZOJ. Sorry for the inconvenience caused.

题意

给出一棵树，其中某些点是红色，其余点是黑色。定义一个点的花费为这个点到距其最近的红色祖先节点的距离。q次查询，每次查询给出k个节点，允许将最多一个黑色点变为红色， 求这k个点中最大花费的最小值。每次查询相互独立，不影响树的初始结构。

题解

dfs处理出每个点距离1点的距离D，每个点距离红色祖先的距离dis

倍增lca预处理，用于查询公共祖先

每个查询q

先将k个点按dis从大到小排序

每次处理第i个节点

1.找到和前一个点的公共祖先

2.如果深度<上一个深度，说明然红的点在上面，需要把前面的最大值+这一段距离

3.然后当前节点本身的dis和把公共祖先染红的新距离取最小

4.2，3操作得到的值取max

5.4操作得到的max和下一个点的dis取max再整体取min，因为有可能节点操作后值变小了，使得最大值为下一个节点

代码

 #include<bits/stdc++.h>

 using namespace std;

 #define fi first

 #define se second

 #define LL long long

 const int maxn=1e5+;

 const int INF=0x3f3f3f3f;

 int R[maxn],cnt[maxn],fa[maxn][],deep[maxn],n,m;

 LL D[maxn],dis[maxn];

 bool red[maxn];

 vector< pair<int,int> >G[maxn];

 void dfs(int x,int f)

 {

     if(red[x])R[x]=x;

     else R[x]=R[f];

     dis[x]=D[x]-D[R[x]];

     for(auto v:G[x])

     {

         if(v.fi==f)continue;

         D[v.fi]=D[x]+v.se;

         deep[v.fi]=deep[x]+;

         fa[v.fi][]=x;

         dfs(v.fi,x);

     }

 }

 bool cmp(LL a,LL b)

 {

     return dis[a]>dis[b];

 }

 void RMQ()

 {

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

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

             fa[i][j]=fa[fa[i][j-]][j-];

 }

 int LCA(int u,int v)

 {

     if(deep[u]<deep[v])swap(u,v);

     int de=log(deep[u])/log(2.0);

     for(int i=de;i>=;i--)

         if(deep[u]-(<<i)>=deep[v])

             u=fa[u][i];

     if(v==u)return u;

     for(int i=de;i>=;i--)

         if(fa[u][i]!=fa[v][i])

             u=fa[u][i],v=fa[v][i];

     return fa[v][];

 }

 int main()

 {

     int t,q,a,b,c,k;

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d%d",&n,&m,&q);

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

             red[i]=,G[i].clear();

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

             scanf("%d",&a),red[a]=;

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

         {

             scanf("%d%d%d",&a,&b,&c);

             G[a].push_back(make_pair(b,c));

             G[b].push_back(make_pair(a,c));

         }

         D[]=dis[]=dis[n+]=;

         dfs(,);

         RMQ();

         while(q--)

         {

             scanf("%d",&k);

             LL ans=,maxx=,lon;

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

                 scanf("%d",&cnt[i]);

             cnt[k]=n+;

             sort(cnt,cnt+k,cmp);

             int far=cnt[];

             ans=min(dis[cnt[]],dis[cnt[]]);

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

             {

                 int mom=LCA(far,cnt[i]);//找上一个和当前的公共祖先,染红mom节点

                 if(deep[mom]<deep[far])maxx+=D[far]-D[mom];//如果新祖先深度<上一个祖先深度,最大的距离需要+两个祖先之间的距离

                 lon=min(dis[cnt[i]],D[cnt[i]]-D[mom]);//当前节点本身距离红色祖先的距离和把到mom染红后的节点距离取min

                 maxx=max(lon,maxx);

                 far=mom;

                 ans=min(ans,max(maxx,dis[cnt[i+]]));//保证每次处理最大值

             }

             printf("%lld\n",ans);

         }

     }

     return ;

 }