#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define ff first
#define ss second

const int MAXN = 1e5 + 1;
const int N = 1024 * 128;

vi graf[N];
int tree[2 * N], lazy[2 * N], ile[MAXN], podd[MAXN], skok[MAXN], pre[MAXN], par[MAXN], odz[MAXN];
int timer = 1, korzen;

void dfs(int v, int ojc){
    podd[v] = 1;
    if(graf[v].size() == 1) ile[v]++;
    for(int u : graf[v]){
        if(u == ojc) continue;
        par[u] = v;
        dfs(u, v);
        ile[v] += ile[u];
        podd[v] += podd[u];
    }
}

void decompose(int v, int ojc, int pocz){
    odz[timer] = v;
    pre[v] = timer++;
    skok[v] = pocz;
    int mx = 0, ciezki = 0;
    for(int u : graf[v]){
        if(u == ojc) continue;
        if(mx < podd[u]){
            mx = podd[u]; ciezki = u;
        }
    }

    if(ciezki) decompose(ciezki, v, pocz);
    for(int u : graf[v]){
        if(u == ojc || u == ciezki) continue;
        decompose(u, v, u);
    }
}

void push(int v, int l, int r){
    if(lazy[v]){
        int mid = (l + r) / 2;
        int dl1 = mid - l + 1, dl2 = r - mid;
        tree[2 * v] = dl1 - tree[2 * v];
        tree[2 * v + 1] = dl2 - tree[2 * v + 1];
        lazy[2 * v] ^= 1; lazy[2 * v + 1] ^= 1;
        lazy[v] = 0;
    }
}

void zmien(int v, int l, int r, int ql, int qr){
    if(l > qr || r < ql || r < l) return;
    if(ql <= l && r <= qr){
        int dl = r - l + 1;
        tree[v] = dl - tree[v];
        lazy[v] ^= 1;
        return;
    }

    push(v, l, r);

    int mid = (l + r) / 2;
    zmien(2 * v, l, mid, ql, qr); zmien(2 * v + 1, mid + 1, r, ql, qr);

    tree[v] = tree[2 * v] + tree[2 * v + 1];
}


void upd(int v){
    while(skok[v] != korzen){
        zmien(1, 1, N, pre[skok[v]], pre[v]);
        v = par[skok[v]];
    }
    if(v != korzen){
        zmien(1, 1, N, 2, pre[v]);
    }
}

void solve(){
    int d; cin >> d;
    vi t(d);
    for(int i = 0; i < d; i++) cin >> t[i];
    sort(t.begin(), t.end());
    int utrac = 0;
    vi g;

    for(int i = 0; i < d; ){
        int j = i;
        while(j < d && t[j] == t[i]) j++;
        int v = t[i];
        int cnt = j - i;

        if(graf[v].size() == 1){
            utrac++;
            if(!(cnt & 1)) g.pb(v);
        }else{
            if(cnt & 1) g.pb(v);
        }
        i = j;
    }

    if((d + ile[korzen] - utrac) & 1){ cout << "-1\n"; return; }

    for(int u : g) upd(u);
    cout << 2 * podd[korzen] - tree[1] + d - 2 << "\n";
    for(int u : g) upd(u);
}

void build(int v, int l, int r){
    if(l == r){
        if(l == 1 && l > podd[korzen]) return;
        tree[v] = ile[odz[l]] & 1;
        return;
    }
    int mid = (l + r) / 2;
    build(2 * v, l, mid); build(2 * v + 1, mid + 1, r);

    tree[v] = tree[2 * v] + tree[2 * v + 1];
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n, q;
    cin >> n >> q;

    for(int i = 1; i < n; i++){
        int a, b; cin >> a >> b;
        graf[a].pb(b); graf[b].pb(a);
    }

    for(int i = 1; i <= n; i++){
        if(graf[i].size() > 1){
            korzen = i; break;
        }
    }

    dfs(korzen, 0);
    decompose(korzen, 0, korzen);
    build(1, 1, N);

    while(q--) solve();





    return 0;
}