#include <bits/stdc++.h>

using namespace std;
using ll = long long;
constexpr ll INF = 1e9 + 7;

struct Dinic {

    struct edge {
        ll from, to;
        ll cap, flow;
    };
    ll n;

    vector<vector<ll>> g;
    vector<edge> E;

    Dinic(ll n) : n(n) {
        g.resize(n);
    }

    void addEdge(ll from, ll to, ll cap) {
        g[from].push_back(E.size());
        E.push_back({from, to, cap, 0});
        g[to].push_back(E.size());
        E.push_back({to, from, 0, 0});
    }

    vector<ll> bfs(ll st, ll mn) {
        ll n = g.size();
        vector<ll> d(n, -1);
        d[st] = 0;
        queue<ll> q;
        q.push(st);
        while (!q.empty()) {
            ll v = q.front();
            q.pop();
            for (const auto ind: g[v]) {
                ll to = E[ind].to;
                if (d[to] == -1 && E[ind].cap - E[ind].flow >= mn) {
                    d[to] = d[v] + 1;
                    q.push(to);
                }
            }
        }

        return d;
    }

    ll solve(ll st, ll en) {
        ll res = 0;
        for (ll i = 29; i >= 0; --i) {
            while (1) {
                vector<ll> d = bfs(st, (1ll << i));
                if (d[en] == -1)break;
                vector<ll> ptr(g.size(), 0);
                while (ll add = dfs(st, INF, (1ll << i), en, d, ptr)) {
                    res += add;
                }
            }
        }
        return res;
    }

    ll dfs(ll v, ll flow, const ll mn, const ll end, const vector<ll> &d, vector<ll> &ptr) {
        if (flow < mn) {
            return 0;
        }
        if (v == end) {
            return flow;
        }
        for (; ptr[v] < g[v].size(); ++ptr[v]) {
            ll ind = g[v][ptr[v]];
            ll to = E[ind].to;
            if (d[to] != d[v] + 1)continue;
            if (ll add = dfs(to, min(flow, E[ind].cap - E[ind].flow), mn, end, d, ptr)) {
                E[ind].flow += add;
                E[ind ^ 1].flow -= add;
                return add;
            }
        }
        return 0;
    }
};

void solve() {
    ll n, k;
    cin >> n >> k;
    vector<char> need(n, 0);
    for (ll i = 0; i < k; ++i) {
        ll x;
        cin >> x;
        --x;
        need[x] = 1;
    }
    ll st = 0, en = n + 1;
    Dinic sol(en + 1);
    vector<ll> p(n);
    for (auto &i: p) {
        cin >> i, --i;
    }
    for (ll i = 0; i < n; ++i) {
        if (need[i]) {
            ll nxt = i + 1 < n && need[i + 1] ? i + 1 : -1;
            if (~nxt) {
                sol.addEdge(i + 1, nxt + 1, 1);
                sol.addEdge(nxt + 1, i + 1, 1);
            } else {
                sol.addEdge(i + 1, en, 1);
                sol.addEdge(en, i + 1, 1);
            }
        }
    }
    for (ll j = 0; j < n; ++j) {
        ll i = p[j];
        if (need[i]) {
            ll nxt = j + 1 < n && need[p[j + 1]] ? p[j + 1] : -1;
            if (~nxt) {
                sol.addEdge(i + 1, nxt + 1, 1);
                sol.addEdge(nxt + 1, i + 1, 1);
            } else {
                sol.addEdge(i + 1, st, 1);
                sol.addEdge(st, i + 1, 1);
            }
        }
    }
    cout << sol.solve(st,en) << "\n";
}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--)solve();
}