//generated by ChatGPT
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int query(const vector<int>& bit, int index) {
    int result = 0;

    while (index > 0) {
        result = max(result, bit[index]);
        index -= index & -index;
    }

    return result;
}

void update(vector<int>& bit, int index, int value) {
    const int n = static_cast<int>(bit.size()) - 1;

    while (index <= n) {
        bit[index] = max(bit[index], value);
        index += index & -index;
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<int> P(N), Q(N);

        for (int& x : P) {
            cin >> x;
        }
        for (int& x : Q) {
            cin >> x;
        }

        /*
        less_bit[j]:
            キー P_i に dp[i][j] を格納する Fenwick Tree

        greater_bit[j]:
            キー N - P_i + 1 に dp[i][j] を格納する Fenwick Tree
        */
        vector<vector<int>> less_bit(
            N, vector<int>(N + 1, 0)
        );
        vector<vector<int>> greater_bit(
            N, vector<int>(N + 1, 0)
        );

        vector<int> less_value(N);
        vector<int> greater_value(N);
        vector<int> current_row(N);

        vector<int> q_less_bit(N + 1);
        vector<int> q_greater_bit(N + 1);

        int answer = 1;

        for (int i = 0; i < N; ++i) {
            /*
            less_value[j] =
                max dp[x][j] (x < i, P[x] < P[i])

            greater_value[j] =
                max dp[x][j] (x < i, P[x] > P[i])
            */
            for (int j = 0; j < N; ++j) {
                less_value[j] =
                    query(less_bit[j], P[i] - 1);

                greater_value[j] =
                    query(greater_bit[j], N - P[i]);
            }

            fill(q_less_bit.begin(), q_less_bit.end(), 0);
            fill(q_greater_bit.begin(), q_greater_bit.end(), 0);

            for (int j = 0; j < N; ++j) {
                int increasing =
                    query(q_less_bit, Q[j] - 1);

                int decreasing =
                    query(q_greater_bit, N - Q[j]);

                current_row[j] =
                    1 + max(increasing, decreasing);

                answer = max(answer, current_row[j]);

                /*
                現在の j は、これ以降の位置から見れば y < j
                となるので、計算後に追加する。
                */
                update(
                    q_less_bit,
                    Q[j],
                    less_value[j]
                );

                update(
                    q_greater_bit,
                    N - Q[j] + 1,
                    greater_value[j]
                );
            }

            /*
            同じ行 i の状態が遷移元として使われないよう、
            行全体を計算し終えてから更新する。
            */
            for (int j = 0; j < N; ++j) {
                update(
                    less_bit[j],
                    P[i],
                    current_row[j]
                );

                update(
                    greater_bit[j],
                    N - P[i] + 1,
                    current_row[j]
                );
            }
        }

        cout << answer << '\n';
    }

    return 0;
}