#include <bits/stdc++.h>
using namespace std;

using ll=long long;
#define int ll

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)

#define bg begin()
#define ed end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define all(x) x.bg,x.ed
#define si(x) (int)x.size()

template<class t>using vc=vector<t>;
template<class t>using vvc=vc<vc<t>>;

template<class t,class u>bool chmin(t&a,u b){
	if(a>b){a=b;return true;}
	else return false;
}
template<class t,class u>bool chmax(t&a,u b){
	if(a<b){a=b;return true;}
	else return false;
}
template<class t>using vc=vector<t>;
template<class t>using vvc=vector<vector<t>>;
using vi=vc<int>;
using pi=pair<int,int>;
#define a first
#define b second

template<class E>
struct HLD{
	vvc<E>g;
	int n,rt,cnt;
	vi sub,in,out,par,head,dep,hei,ni;
	vvc<E>bin;
	vc<E>pe;
	int dfs1(int v,int p,int d){
		par[v]=p;
		dep[v]=d;
		for(auto itr=g[v].begin();itr!=g[v].end();itr++)
			if(*itr==p){
				pe[v]=*itr;
				g[v].erase(itr);
				break;
			}
		for(auto &e:g[v]){
			pe[e]=e;
			sub[v]+=dfs1(e,v,d+1);
			if(sub[g[v][0]]<sub[e]) swap(g[v][0],e);
		}
		return sub[v];
	}
	void dfs2(int v,int h){
		in[v]=cnt++;
		head[v]=h;
		for(auto to:g[v])
			dfs2(to,to==g[v][0]?h:to);
		out[v]=cnt;
		if(si(g[v])) hei[v]=hei[g[v][0]]+1;
	}
	HLD(){}
	HLD(const vvc<E>&gg,int rr):g(gg),n(g.size()),rt(rr),cnt(0),
		sub(n,1),in(n),out(n),par(n,-1),head(n),dep(n),hei(n,1),ni(n),
		pe(n){
			dfs1(rt,-1,0);
			dfs2(rt,rt);
			rep(i,n)ni[in[i]]=i;
			bin.resize(20);
			bin[0] = par;
			rep(j, 19){
				bin[j+1].resize(n);
				rep(i, n){
					if(bin[j][i]==-1) bin[j+1][i]=-1;
					else bin[j+1][i]=bin[j][bin[j][i]];
				}
			}
	}
	int up(int v,int a){
		rep(j, 20){
			if(((a>>j)&1)) v = bin[j][v];
		}
		return v;
	}
	int lca(int a,int b){
		while(head[a]!=head[b]){
			if(dep[head[a]]>dep[head[b]]){
				swap(a,b);
			}
			b=par[head[b]];
		}
		if(dep[a]>dep[b]) swap(a,b);
		return a;
	}
	int len(int a,int b){
		return dep[a]+dep[b]-dep[lca(a,b)]*2;
	}
	bool asde(int a,int b){
		return in[a]<=in[b] and out[b]<=out[a];
	}
	
	vi index;
	pair<vi,vc<pi>>tree_compress(vi vs){
		if(index.size()==0) index.resize(n);
		auto comp=[&](int x,int y){
			return in[x]<in[y];
		};
		sort(vs.begin(), vs.end(), comp);
		vs.erase(unique(vs.begin(), vs.end()),vs.end());
		int k=vs.size();
		rep(i,k-1){
			vs.pb(lca(vs[i],vs[i+1]));
		}
		sort(vs.begin(), vs.end(), comp);
		vs.erase(unique(vs.begin(), vs.end()),vs.end());
		k=vs.size();
		rep(i,k)index[vs[i]]=i;
		vc<pi>es;
		rng(i,1,k){
			int p=lca(vs[i-1],vs[i]);
			es.eb(i,index[p]);
		}
		return mp(vs, es);
	}
};
struct BIT{
	vc<int>b;
	int sz;
	void init(int a){
		sz = a+3;
		b.clear();
		b.assign(sz, 0);
	}
	void add(int i, int v){
		i ++;
		for(;i<sz;i+=i&-i) b[i] += v;
	}
	int sum(int i){
		i ++;
		int ret=0;
		for(;i;i-=i&-i) ret += b[i];
		return ret;
	}
}bit;
using P=pi;
int sol(vc<int>A, vc<int>info, vc<pi>edge){
	unordered_map<int,int>M;
	rep(i, A.size()){
		M[A[i]] = i;
	}
	int n = A.size();
	vc<int>imp(n);
	for(auto v:info) imp[M[v]] = 1;
	
	vvc<int>g; g.resize(n);
	for(auto uv:edge){
		g[uv.a].pb(uv.b);
		g[uv.b].pb(uv.a);
	}
	HLD<int>h2(g, 0);
	vc<int>sum2(n);
	auto dfs0=[&](int v,int u,auto dfs0)->void{
		sum2[v] += imp[v];
		for(auto to:g[v]){
			if(to==u)continue;
			sum2[to] = sum2[v];
			dfs0(to,v,dfs0);
		}
	};
	dfs0(0,-1,dfs0);
	//for(auto x:A) cout << x << " "; cout << endl;
	//for(auto x:info) cout << x << " "; cout << endl;
	//for(auto x:edge) cout << x.a << " " << x.b << endl;
	//rep(i, n) cout << sum2[i] << " "; cout << endl;
	vvc<P>q; q.resize(n);
	int pre=0;
	rng(i, 1, info.size()){
		int u = M[info[i-1]];
		int v = M[info[i]];
		int w = h2.lca(u, v);
		if(sum2[u]+sum2[v]-sum2[w]*2+imp[w] != 2) continue;
		//cerr<<info[i-1]<<" "<<info[i]<<endl;
		int L = h2.len(u, v);
			
			if(L == 1) pre++;
			else if(L == 2){
				int mid;
				if(u != w) mid=(h2.up(u, 1));
				else mid=(h2.up(v, 1));
				q[mid].eb(mid, mid);
			}
			else{
				int mid1, mid2;
				if(u != w) mid1=(h2.up(u, 1));
				else mid1=(h2.up(v, L-1));
				
				if(v != w) mid2=(h2.up(v, 1));
				else mid2=(h2.up(u, L-1));
				
				q[h2.lca(mid1, mid2)].eb(mid1, mid2);
			}
	}
	bit.init(n+1);
	vc<int>sum(n), dp(n);
	
	
	auto dfs=[&](int v, int u, auto dfs) -> void{
		for(auto to:g[v]){
			if(to == u) continue;
			dfs(to, v, dfs);
			sum[v] += dp[to];
		}
		dp[v] = sum[v];
		for(auto edd:q[v]){
			int tmp=1;
			int x[2]={edd.a, edd.b};
			rep(_, 2){
				int p = x[_];
				if(p == v) continue;
				int L = h2.len(p, v);
				int ch = h2.up(p, L-1);
				tmp += sum[ch]-dp[ch];
				if(L > 1){
					tmp += bit.sum(h2.in[p]);
					tmp -= bit.sum(h2.in[ch]);
				}
			}
			if(dp[v] < sum[v]+tmp) dp[v] = sum[v]+tmp;
		}
		bit.add(h2.in[v], sum[v]-dp[v]);
		bit.add(h2.out[v], sum[v]-dp[v]);
	};
	dfs(0, -1, dfs);
	return dp[0]+pre;
}
void slv(){
	int n,m;
	cin>>n>>m;
	vvc<int>g; g.resize(n);
	rep(i,n-1){
		int u,v;cin>>u>>v;
		u--; v--;
		g[u].pb(v);
		g[v].pb(u);
	}
	HLD<int>h1(g, 0);
	
	rep(_, m){
		int k; cin >> k;
		vc<int>vec(k);
		rep(i, k) cin >> vec[i];
		if(k <= 2){
			cout << 0 << '\n';
			continue;
		}
		rep(i, k) vec[i]--;
		vc<int>A = vec;
		rep(i, k-1){
			int u = vec[i];
			int v = vec[i+1];
			int L = h1.len(u, v);
			
			if(L == 1) continue;
			else if(L == 2){
				int w = h1.lca(u, v);
				if(u != w) A.pb(h1.up(u, 1));
				else A.pb(h1.up(v, 1));
			}
			else{
				int w = h1.lca(u, v);
				if(u != w) A.pb(h1.up(u, 1));
				else A.pb(h1.up(v, L-1));
				//cout<<u<<" "<<v<<endl;
				//cout<<A.back()<<" ";
				
				if(v != w) A.pb(h1.up(v, 1));
				else A.pb(h1.up(u, L-1));
				//cout<<A.back()<<endl;
				//cout<<"_____"<<endl;
			}
		}
		//for(auto a:A) cout<<a<<" ";cout<<endl;
		auto ret = h1.tree_compress(A);
		//for(auto a:ret.a) cout<<a<<" ";cout<<endl;
		//for(auto b:ret.b) cout<<b.a<<" "<<b.b<<endl;
		cout << k-1-sol(ret.a, vec, ret.b) << '\n';
	}
}

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	
	int t;t=1;//cin>>t;
	while(t--) slv();
}