Kingdom and its Cities - CF613D

Meanwhile, the kingdom of K is getting ready for the marriage of the King's daughter. However, in order not to lose face in front of the relatives, the King should first finish reforms in his kingdom. As the King can not wait for his daughter's marriage, reforms must be finished as soon as possible.

The kingdom currently consists of n cities. Cities are connected by n - 1 bidirectional road, such that one can get from any city to any other city. As the King had to save a lot, there is only one path between any two cities.

What is the point of the reform? The key ministries of the state should be relocated to distinct cities (we call such cities important). However, due to the fact that there is a high risk of an attack by barbarians it must be done carefully. The King has made several plans, each of which is described by a set of important cities, and now wonders what is the best plan.

Barbarians can capture some of the cities that are not important (the important ones will have enough protection for sure), after that the captured city becomes impassable. In particular, an interesting feature of the plan is the minimum number of cities that the barbarians need to capture in order to make all the important cities isolated, that is, from all important cities it would be impossible to reach any other important city.

Help the King to calculate this characteristic for each of his plan.

Input

The first line of the input contains integer n (1 ≤ n ≤ 100 000) — the number of cities in the kingdom.

Each of the next n - 1 lines contains two distinct integers u_i, v_i (1 ≤ u_i, v_i ≤ n) — the indices of the cities connected by the i-th road. It is guaranteed that you can get from any city to any other one moving only along the existing roads.

The next line contains a single integer q (1 ≤ q ≤ 100 000) — the number of King's plans.

Each of the next q lines looks as follows: first goes number k_i — the number of important cities in the King's plan, (1 ≤ k_i ≤ n), then follow exactly k_i space-separated pairwise distinct numbers from 1 to n — the numbers of important cities in this plan.

The sum of all k_i's does't exceed 100 000.

Output

For each plan print a single integer — the minimum number of cities that the barbarians need to capture, or print  - 1 if all the barbarians' attempts to isolate important cities will not be effective.

Sample test(s)

Input

4
1 3
2 3
4 3
4
2 1 2
3 2 3 4
3 1 2 4
4 1 2 3 4

Output

1
-1
1
-1

Input

7
1 2
2 3
3 4
1 5
5 6
5 7
1
4 2 4 6 7

Output

2

Note

In the first sample, in the first and the third King's plan barbarians can capture the city 3, and that will be enough. In the second and the fourth plans all their attempts will not be effective.

In the second sample the cities to capture are 3 and 5.

简单题意

给你一棵树，树上有n个点，然后给q个询问，每次给一些点，求最少要删掉多少点（不能删掉给出的点）才能使这些点分开(给出的总点数小于等于10^5）

胡说题解

其实我们能想到，跟答案有关的点其实就是这些点之间的LCA，其实就是要我们构造这颗虚树，然后在这个虚树上面DP

然后就是虚树的构造方法，按dfs序排序，然后动态的向虚树中加点，我们用栈来维护这颗虚树的最右边的那条链（因为我们按照dfs序排序了，加点只会跟最右边的这条链有关），每次新的点与栈顶的点求LCA，然后根据高度将栈顶的一些点弹出（自己画画图），再加入LCA和新点，这里要注意边怎么连（还是自己多画画图，分情况讨论）

将虚树构造出来后我们就可以在虚树上DP了，这个DP还比较好想，我就不多说了

傻逼错误

一开始想到求LCA，然后就开始乱搞，排序之后直接求LCA然后看这个点是不是给出的点，然后过了两个样例开开心心的交了，然后就傻逼了，WA on test3

然后各种错误，过了好久才知道要求虚树，临时学虚树怎么求，反正各种坑

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 using namespace std;

 const int maxn=;
 int n,q,first[maxn],last[maxn*],next[maxn*],fa[maxn],tot,num,time[maxn],i;
 int ll[maxn*][],rr[maxn*][],l[maxn],dep[maxn],s[maxn],stack[maxn];
 bool flag[maxn];

 void insert(int x,int y){
     if(x&y==)return;
     last[++tot]=y;
     next[tot]=first[x];
     first[x]=tot;
 }

 bool cmp(int a,int b){
     return l[a]<l[b];
 }

 bool cmp2(int a,int b){
     return dep[a]<dep[b];
 }

 void dfs(int x,int d){
     flag[x]=true;
     dep[x]=d;
     ll[++num][]=x;
     l[x]=num;
     int i=first[x];
     while(i!=){
         if(!flag[last[i]]){
             dfs(last[i],d+);
             ll[++num][]=x;
             fa[last[i]]=x;
         }
         i=next[i];
     }
 }

 int lca(int a,int b){
     int tmp;
     tmp=l[b]-l[a]+;
     tmp=trunc(log(tmp)/log());
     if(cmp2(ll[l[a]][tmp],rr[l[b]][tmp]))tmp=ll[l[a]][tmp];
     else tmp=rr[l[b]][tmp];
     return tmp;
 }

 int dp(int x){
     int tmp=,num=,j=first[x];
     while(j!=){
         tmp+=dp(last[j]);
         if(time[last[j]]==*i)++num;
         j=next[j];
     }
     if(time[x]==*i)tmp+=num;
     else
         if(num>)++tmp;
         else if(num==)time[x]=*i;
     return tmp;
 }

 int main(){
     scanf("%d",&n);
     int x,y;
     for(i=;i<n;i++){
         scanf("%d%d",&x,&y);
         insert(x,y);
         insert(y,x);
     }
     dfs(,);
     for(i=;i<=num;i++)rr[i][]=ll[i][];
     for(i=;<<(i-)<num;i++){
         for(x=;num-x>=<<(i-);x++)
         if(cmp2(ll[x][i-],ll[x+(<<(i-))][i-]))ll[x][i]=ll[x][i-];
         else ll[x][i]=ll[x+(<<(i-))][i-];
         for(x=num-(<<(i-))+;x<=num;x++)ll[x][i]=ll[x][i-];
         for(x=;num-x>=<<(i-);x++)
         if(cmp2(rr[x][i-],rr[x+(<<(i-))][i-]))rr[x+(<<(i-))][i]=rr[x][i-];
         else rr[x+(<<(i-))][i]=rr[x+(<<(i-))][i-];
         for(x=;x<=<<(i-);x++)rr[x][i]=rr[x][i-];
     }
     scanf("%d",&q);
     bool f;
     int tmp,now,lasti;
     for(i=;i<=q;i++){
         scanf("%d",&x);
         for(y=;y<=x;y++)scanf("%d",&s[y]);
         sort(s+,s++x,cmp);
         f=true;y=x;
         stack[]=s[];now=;
         for(x=;x<=y;x++)time[s[x]]=*i;
         tot=;first[s[]]=;
         for(x=;x<=y;x++){
             lasti=;first[s[x]]=;
             tmp=lca(stack[now],s[x]);
             if(time[tmp]==*i && fa[s[x]]==tmp)f=false;
             if(!f)break;
             while(now> && dep[stack[now]]>dep[tmp])lasti=stack[now--];
             if(time[tmp]<i*-)time[tmp]=*i-,first[tmp]=;
             if(stack[now]==tmp){
                 insert(tmp,s[x]);
                 stack[++now]=s[x];
             }
             else{
                 first[stack[now]]=next[first[stack[now]]];
                 insert(stack[now],tmp);
                 insert(tmp,lasti);
                 insert(tmp,s[x]);
                 stack[++now]=tmp;
                 stack[++now]=s[x];
             }
         }
         if(!f)printf("-1\n");
         else printf("%d\n",dp(stack[]));
     }
     return ;
 }

AC代码