#include <bits/stdc++.h>

using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n==0) ? 1 : 10*TEN(n-1); }
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;


template<class T> ostream& operator<<(ostream& os, const V<T> &v) {
    cout << "[";
    for (auto p: v) cout << p << ", ";
    cout << "]";
    return os;
}

struct Solver {
    int n;
    VV<int> src, trg;
    V<int> s_par, t_par;
    void dfs(const VV<int> &g, V<int> &par, int p, int b) {
        par[p] = b;
        for (int d: g[p]) {
            if (d == b) continue;
            dfs(g, par, d, p);
        }
    }
    int check(int r) {
        s_par = V<int>(n);
        t_par = V<int>(n);
        dfs(src, s_par, r, -1);
        dfs(trg, t_par, r, -1);
        V<int> nch(n);
        for (int d: s_par) {
            if (d != -1) nch[d]++;
        }
        //cout << "SPAR: " << s_par << endl;
        //cout << "TPAR: " << t_par << endl;
        int cnt = 0;
        V<bool> ok(n);
        ok[r] = true;
        while (true) {
            bool update = false;
            for (int p = 0; p < n; p++) {
                if (ok[p]) continue;
                if (s_par[p] != t_par[p]) continue;
                if (!ok[s_par[p]]) continue;
                update = true;
                ok[p] = true;
            }
            if (update) continue;
            for (int p = 0; p < n; p++) {
                if (ok[p]) continue;
                if (nch[p]) continue;
                if (!ok[t_par[p]]) continue;
                cnt++;
                update = true;
                nch[s_par[p]]--;
                ok[p] = true;
                break;
            }
            if (update) continue;

            break;
        }
        for (int p = 0; p < n; p++) {
            if (!ok[p]) return TEN(9);
        }
        return cnt;
    }
    int solve() {
        int ans = TEN(9);
        cin >> n;
        VV<int> _src(n);
        trg = VV<int>(n);
        for (int i = 0; i < n-1; i++) {
            int a, b;
            cin >> a >> b; a--; b--;
            _src[a].push_back(b);
            _src[b].push_back(a);
        }
        for (int i = 0; i < n-1; i++) {
            int a, b;
            cin >> a >> b; a--; b--;
            trg[a].push_back(b);
            trg[b].push_back(a);
        }
        {
            bool same = true;
            for (int p = 0; p < n; p++) {
                set<int> s1(_src[p].begin(), _src[p].end());
                set<int> s2(trg[p].begin(), trg[p].end());
                if (s1 != s2) same = false;
            }
            if (same) return 0;
        }
        for (int p = 0; p < n; p++) {
            if (_src[p].size() != 1) continue;
            int px = _src[p][0];
            for (int q = 0; q < n; q++) {
                if (p == q) continue;
                //if (p != 0 || q != 1) continue;
                src = _src;
                src[p].clear();
                src[px].erase(
                        remove_if(src[px].begin(), src[px].end(), [&](int x){ return x == p; }),
                        src[px].end());
                src[p].push_back(q);
                src[q].push_back(p);
                int z = check(p);
                ans = min(ans, z + 1);
            }
        }
        return ans;
    }
};

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << setprecision(20) << fixed;
    int t;
    cin >> t;
    for (int ph = 0; ph < t; ph++) {
        Solver s;
        int ans = s.solve();
        if (ans > TEN(8)) ans = -1;
        cout << ans << endl;
    }
    return 0;
}


Measured memory_bytes: 256