#include <bits/stdc++.h>

using namespace std;

int main() {
#ifdef wxh010910
  freopen("input.txt", "r", stdin);
#endif
  int T;
  scanf("%d", &T);
  while (T--) {
    int n;
    scanf("%d", &n);
    vector<vector<int>> a(n), b(n);
    for (int i = 0; i < n - 1; ++i) {
      int x, y;
      scanf("%d %d", &x, &y);
      --x;
      --y;
      a[x].push_back(y);
      a[y].push_back(x);
    }
    for (int i = 0; i < n - 1; ++i) {
      int x, y;
      scanf("%d %d", &x, &y);
      --x;
      --y;
      b[x].push_back(y);
      b[y].push_back(x);
    }
    for (int i = 0; i < n; ++i) {
      sort(a[i].begin(), a[i].end());
      sort(b[i].begin(), b[i].end());
    }
    bool same = true;
    for (int i = 0; i < n; ++i) {
      if (a[i] != b[i]) {
        same = false;
        break;
      }
    }
    if (same) {
      puts("0");
    } else {
      int answer = n;
      int dfn_t = 0;

      vector<int> parent_a(n), parent_b(n), begin_a(n), begin_b(n), end_a(n), end_b(n);
      vector<bool> same(n);
      int dfn, result;

      function<void(int, int)> dfs_a = [&](int x, int p) {
        begin_a[x] = dfn++;
        parent_a[x] = p;
        for (auto y : a[x]) {
          if (y != p) {
            dfs_a(y, x);
          }
        }
        end_a[x] = dfn;
      };
      
      function<void(int, int)> dfs_b = [&](int x, int p) {
        begin_b[x] = dfn++;
        parent_b[x] = p;
        if (~p) {
          same[x] = parent_a[x] == parent_b[x] && same[p];
          if (same[x]) {
            ++result;
          }
        } else {
          same[x] = true;
          result = 1;
        }
        for (auto y : b[x]) {
          if (y != p) {
            dfs_b(y, x);
          }
        }
        end_b[x] = dfn;
      };

      auto solve = [&](int p) {
        dfn = 0;
        dfs_a(p, -1);
        dfn = 0;
        dfs_b(p, -1);
        vector<vector<int>> adj(n);
        vector<int> degree(n);
        for (int i = 0; i < n; ++i) {
          if (i != p && !same[i] && !same[parent_a[i]]) {
            adj[i].push_back(parent_a[i]);
            ++degree[parent_a[i]];
          }
        }
        for (int i = 0; i < n; ++i) {
          if (i != p && !same[i] && !same[parent_b[i]]) {
            adj[parent_b[i]].push_back(i);
            ++degree[i];
          }
        }
        queue<int> q;
        for (int i = 0; i < n; ++i) {
          if (!degree[i]) {
            q.push(i);
          }
        }
        while (!q.empty()) {
          int x = q.front();
          q.pop();
          for (auto y : adj[x]) {
            if (!--degree[y]) {
              q.push(y);
            }
          }
        }
        for (int i = 0; i < n; ++i) {
          if (degree[i]) {
            return;
          }
        }
        answer = min(answer, n - result);
      };

      for (int i = 0; i < n; ++i) {
        if (b[i].size() == 1) {
          int p = b[i][0];
          for (int j = 0; j < b[p].size(); ++j) {
            if (b[p][j] == i) {
              swap(b[p][j], b[p][b[p].size() - 1]);
              break;
            }
          }
          for (int j = 0; j < n; ++j) {
            b[i].pop_back();
            b[p].pop_back();
            b[i].push_back(j);
            b[j].push_back(i);
            solve(i);
            b[i].pop_back();
            b[j].pop_back();
            b[i].push_back(p);
            b[p].push_back(i);
          }
        }
      } 
      if (answer == n) {
        puts("-1");
      } else {
        printf("%d\n", answer + 1);
      }
    }
  }
  return 0;
}


Measured memory_bytes: 256