// ---------- begin chmin, chmax ----------
pub trait ChangeMinMax {
    fn chmin(&mut self, x: Self) -> bool;
    fn chmax(&mut self, x: Self) -> bool;
}

impl<T: PartialOrd> ChangeMinMax for T {
    fn chmin(&mut self, x: Self) -> bool {
        *self > x && {
            *self = x;
            true
        }
    }
    fn chmax(&mut self, x: Self) -> bool {
        *self < x && {
            *self = x;
            true
        }
    }
}
// ---------- end chmin, chmax ----------
// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::io::Write;
use std::collections::*;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}

fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    let t: u32 = sc.next();
    for _ in 0..t {
        let n: usize = sc.next();
        let k: usize = sc.next();
        let u = sc.next_vec::<usize>(k);
        let p = sc.next_vec::<usize>(n);
        let ans = solve(n, u, p);
        writeln!(out, "{}", ans).ok();
    }
}

fn solve(n: usize, u: Vec<usize>, p: Vec<usize>) -> i32 {
    let u = u.into_iter().map(|u| u - 1).collect::<Vec<_>>();
    let p = p.into_iter().map(|p| p - 1).collect::<Vec<_>>();
    let mut ip = vec![0; n];
    for (i, p) in p.iter().enumerate() {
        ip[*p] = i;
    }
    let mut del = vec![false; n];
    let mut cdel = vec![false; n];
    for u in u.iter() {
        del[*u] = true;
        cdel[ip[*u]] = true;
    }
    let inf = 10000i32;
    // dp[x][y][a][b]: a..n, p[b..n] を削除した、現在のソートはa, 削除操作を続けてるかb
    let mut dp = vec![vec![inf; n + 1]; n + 1];
    dp[n][n] = 0;
    for i in (0..(n + 1)).rev() {
        let mut x = del.clone();
        for j in (0..(n + 1)).rev() {
            let mut val = dp[i][j];
            if i > 0 && x[i - 1] {
                dp[i - 1][j].chmin(val);
            } else if j > 0 && cdel[j - 1] {
                dp[i][j - 1].chmin(val);
            } else {
                val += 1;
                for k in (0..i).rev() {
                    if x[k] {
                        break;
                    }
                    dp[k][j].chmin(val);
                }
                for k in (0..j).rev() {
                    if cdel[k] {
                        break;
                    }
                    dp[i][k].chmin(val);
                }
            }
            if j > 0 {
                x[p[j - 1]] = true;
            }
        }
        if i > 0 {
            del[i - 1] = true;
            cdel[ip[i - 1]] = true;
        }
    }
    dp[0][0]
}