#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

using namespace std;

// Disjoint Set Union to find connected components
struct DSU {
    vector<int> parent;
    DSU(int n) {
        parent.resize(n + 1);
        iota(parent.begin(), parent.end(), 0);
    }
    int find(int i) {
        if (parent[i] == i)
            return i;
        return parent[i] = find(parent[i]);
    }
    void unite(int i, int j) {
        int root_i = find(i);
        int root_j = find(j);
        if (root_i != root_j) {
            parent[root_i] = root_j;
        }
    }
};

void solve() {
    int n;
    cin >> n;
    vector<int> a(n), b(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    for (int i = 0; i < n; i++) cin >> b[i];

    vector<int> in(n + 1, 0), out(n + 1, 0);
    vector<char> has_edge(n + 1, 0);
    DSU dsu(n);

    // Build the graph degrees and components
    for (int i = 0; i < n; i++) {
        int u = a[i];
        int v = b[i];
        out[u]++;
        in[v]++;
        dsu.unite(u, v);
        has_edge[u] = 1;
        has_edge[v] = 1;
    }

    // Calculate total imbalance jumps needed
    long long d_total = 0;
    for (int i = 1; i <= n; i++) {
        if (out[i] > in[i]) {
            d_total += out[i] - in[i];
        }
    }

    vector<char> is_root(n + 1, 0);
    vector<char> is_balanced(n + 1, 1);

    // Analyze the components
    for (int i = 1; i <= n; i++) {
        if (has_edge[i]) {
            int r = dsu.find(i);
            is_root[r] = 1;
            if (in[i] != out[i]) {
                is_balanced[r] = 0; // Component has a degree mismatch
            }
        }
    }

    int comp = 0;
    int bal = 0;
    for (int i = 1; i <= n; i++) {
        if (is_root[i]) {
            comp++;
            if (is_balanced[i]) {
                bal++;
            }
        }
    }

    // Determine the minimum jumps required
    int j = 0;
    if (d_total > 0) {
        j = d_total + bal;
    } else {
        if (comp == 1) {
            j = 0;
        } else {
            j = comp;
        }
    }

    // Matches is Total Edges minus Jumps
    cout << n - j << "\n";
}

int main() {
    // Fast I/O
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    int t;
    if (cin >> t) {
        while (t--) {
            solve();
        }
    }
    return 0;
}