Problem:
Score : 1900 points

Problem Statement

Snuke has found two trees A and B, each with N vertices numbered 1 to N.
The i-th edge of A connects Vertex a_i and b_i, and the j-th edge of B connects Vertex c_j and d_j.
Also, all vertices of A are initially painted white.

Snuke would like to perform the following operation on A zero or more times so that A coincides with B:

Choose a leaf vertex that is painted white. (Let this vertex be v.)

Remove the edge incident to v, and add a new edge that connects v to another vertex.

Paint v black.

Determine if A can be made to coincide with B, ignoring color. If the answer is yes, find the minimum number of operations required.

You are given T cases of this kind. Find the answer for each of them.

Constraints

1 \leq T \leq 20

3 \leq N \leq 50

1 \leq a_i,b_i,c_i,d_i \leq N

All given graphs are trees.

Input

Input is given from Standard Input in the following format:

T
case_1
:
case_{T}

Each case is given in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 d_1
:
c_{N-1} d_{N-1}

Output

For each case, if A can be made to coincide with B ignoring color, print the minimum number of operations required, and print -1 if it cannot.

Sample Input 1

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

Sample Output 1

1
-1

The graph in each case is shown below.

In case 1, A can be made to coincide with B by choosing Vertex 1, removing the edge connecting 1 and 2, and adding an edge connecting 1 and 3. Note that Vertex 2 is not a leaf vertex and thus cannot be chosen.

Sample Input 2

3
8
2 7
4 8
8 6
7 1
7 3
5 7
7 8
4 2
5 2
1 2
8 1
3 2
2 6
2 7
4
1 2
2 3
3 4
3 4
2 1
3 2
9
5 3
4 3
9 3
6 8
2 3
1 3
3 8
1 7
4 1
2 8
9 6
3 6
3 5
1 8
9 7
1 6

Sample Output 2

6
0
7

A may coincide with B from the beginning.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;
#define Re return
#define In inline
#define Rg register
#define St static
#define Op operator
#define bCnt __builtin_popcountll
#define bCtz __builtin_ctzll
#define inc(l, i, r) for(Rg int i=l; i<r; ++i)
#define dec(l, i, r) for(Rg int i=r; i>l; --i)
typedef long long ll;

ll leaf, leafa, leafb, c, que, vis, va[64], vb[64], w[64];

int ans=233;

In void move(int v)
{
    leaf^=1ll<<v;
    if(bCnt(w[bCtz(w[v])]^=1ll<<v)==1)
        leaf|=1ll<<bCtz(w[v]);
    que&=-1ll-(1ll<<v), c|=1ll<<v;
    que|=vb[v]&~c;
}

In void work()
{
    Rg int cnt=1;
    for(;que&leaf;)
    {
        ++cnt;
        move(bCtz(que&leaf));
    }
    if(!que)
        ans=min(ans, cnt);
}

void DFS(int u)
{
    vis|=1ll<<u;
    c|=1ll<<u;
    que&=-1ll-(1ll<<u);
    que|=vb[u]&~c;
    for(ll e=va[u]&vb[u]&~vis; e; e^=e&-e)
        DFS(bCtz(e));
}

int main()
{
//    init();
    St int T;
    for(scanf("%d", &T); T--;)
    {
        St int n;
        scanf("%d", &n);
        inc(1, i, n+1)
            va[i]=0, vb[i]=0;
        ans=233;
        inc(1, i, n)
        {
            St int x, y;
            scanf("%d%d", &x, &y);
            va[x]|=1ll<<y, va[y]|=1ll<<x;
        }
        inc(1, i, n)
        {
            St int x, y;
            scanf("%d%d", &x, &y);
            vb[x]|=1ll<<y, vb[y]|=1ll<<x;
        }
        leafa=leafb=0;
        inc(1, i, n+1)
        {
            if(bCnt(va[i])==1)
                leafa|=1ll<<i;
            if(bCnt(vb[i])==1)
                leafb|=1ll<<i;
        }
        inc(1, i, n+1)
            if(leafa&1ll<<i)
                inc(1, j, n+1)
                    if(i^j)
                    {
                        c=que=0;
                        leaf=leafa;
                        inc(1, k, n+1)
                            w[k]=va[k];
                        move(i);
                        w[j]|=1ll<<i;
                        leaf&=-1-(1ll<<j);
                        work();
                    }
        inc(1, i, n+1)
            if(leafa&1ll<<i)
                inc(1, j, n+1)
                    if(vb[i]&1ll<<j)
                    {
                        vis=c=que=0;
                        leaf=leafa;
                        inc(1, k, n+1)
                            w[k]=va[k];
                        DFS(j);
                        if(c==(1ll<<n+1)-2) ans=0;
                        move(i);
                        work();
                    }
        printf("%d\n", ans==233? -1: ans);
    }
    Re 0;
}