#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

template <typename T> struct dinic {
    struct edge {
        int to;
        T c, f;
    };
    T eps;
    const T inf = numeric_limits<T>::max();
    int n, m = 0;
    vector<edge> e;
    vector<vector<int>> g;
    vector<int> level, ptr;
    dinic(int n) : n(n), g(n), level(n), ptr(n) { eps = (T)1 / (T)1e9; }
    void add_edge(int s, int t, T c) {
        e.push_back({t, c, 0});
        e.push_back({s, 0, 0});
        g[s].push_back(m++);
        g[t].push_back(m++);
    }
    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);
        level[s] = 0;
        for (queue<int> q({s}); q.size(); q.pop()) {
            int s = q.front();
            for (int i : g[s]) {
                int t = e[i].to;
                if (level[t] == -1 and (e[i].c - e[i].f) > eps) {
                    level[t] = level[s] + 1;
                    q.push(t);
                }
            }
        }
        return (level[t] != -1);
    }
    T dfs(int s, int t, T psh) {
        if (!(psh > eps) or s == t) return psh;
        for (int &i = ptr[s]; i < (int)g[s].size(); ++i) {
            auto &eg = e[g[s][i]];
            if (level[eg.to] != level[s] + 1 or !(eg.c - eg.f > eps)) continue;
            T f = dfs(eg.to, t, min(psh, eg.c - eg.f));
            if (f > eps) {
                eg.f += f;
                e[g[s][i] ^ 1].f -= f;
                return f;
            }
        }
        return 0;
    }
    T max_flow(int s, int t) {
        T f = 0;
        while (bfs(s, t)) {
            fill(ptr.begin(), ptr.end(), 0);
            while (1) {
                T c = dfs(s, t, inf);
                if (c > eps) {
                    f += c;
                } else {
                    break;
                }
            }
        }
        return f;
    }
    // ABC239-G
    vector<bool> min_cut(int s) {
        vector<bool> visited(n);
        queue<int> q;
        q.push(s);
        while (q.size()) {
            int p = q.front();
            q.pop();
            visited[p] = true;
            for (auto idx : g[p]) {
                auto eg = e[idx];
                if (eg.c - eg.f > eps and !visited[eg.to]) {
                    visited[eg.to] = true;
                    q.push(eg.to);
                }
            }
        }
        return visited;
    }
};

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q; cin >> q;
    while (q--) {
        int n, k; cin >> n >> k;
        vector<bool> used(k);
        for (int i = 0; i < k; ++i) {
            int x; cin >> x; x -= 1;
            used[x] = true;
        }
        vector<int> p(n);
        for (int i = 0; i < n; ++i) {
            cin >> p[i]; p[i] -= 1;
        }

        vector<pair<int,int>> v, vv;
        int res = 0;
        for (int i = 0; i+1 < n; ++i) {
            if (used[p[i]] and used[p[i+1]]) {
                v.push_back({p[i], p[i+1]});
                res += 1;
            }
            if (used[i] and used[i+1]) {
                vv.push_back({i, i+1});
                res += 1;
            }
        }
        int S = n+n+v.size()+vv.size(), T = S+1;
        dinic<int> g(T+1);
        for (int i = 0; i < n; ++i) {
            if (used[i]) {
                g.add_edge(i, i+n, 1e9);
                g.add_edge(i+n, i, 1e9);
                g.add_edge(i, T, 1);
                g.add_edge(S, i+n, 1);
            }
        }
        for (int i = 0; i < v.size(); ++i) {
            auto u = v[i];
            g.add_edge(u.first+n, 2*n+i, 1e9);
            g.add_edge(u.second+n, 2*n+i, 1e9);
            g.add_edge(2*n+i, T, 1);
        }
        for (int i = 0; i < vv.size(); ++i) {
            auto u = vv[i];
            g.add_edge(2*n+v.size()+i, u.first, 1e9);
            g.add_edge(2*n+v.size()+i, u.second, 1e9);
            g.add_edge(S, 2*n+v.size()+i, 1);
        }
        cout << g.max_flow(S,T)-res << "\n";
    }
}