#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

template <typename T>
struct lazy_segment_tree {
    static const int N = 5e5 + 10;
    const T inf = numeric_limits<T>::max() / 2 - 10;
    const T good_value = -inf;
    T t[4 * N], ch[4 * N];
    T merge(T a, T b) {
        return max(a, b);
    }
    void push(int v, int tl, int tr) {
        if (!ch[v]) return;
        t[v] += ch[v];
        if (tl < tr) {
            ch[v + v] += ch[v];
            ch[v + v + 1] += ch[v];
        }
        ch[v] = 0;
    }
    void update(int l, int r, T x, int v = 1, int tl = 0, int tr = N - 1) {
        push(v, tl, tr);
        if (r < tl || tr < l) return;
        if (l <= tl && tr <= r) {
            ch[v] += x;
            push(v, tl, tr);
            return;
        }
        int tm = (tl + tr) / 2;
        update(l, r, x, v + v, tl, tm);
        update(l, r, x, v + v + 1, tm + 1, tr);
        t[v] = merge(t[v + v], t[v + v + 1]);
    }
    T get(int l, int r, int v = 1, int tl = 0, int tr = N - 1) {
        push(v, tl, tr);
        if (r < tl || tr < l) return good_value;
        if (l <= tl && tr <= r) return t[v];
        int tm = (tl + tr) / 2;
        T res = merge(get(l, r, v + v, tl, tm), get(l, r, v + v + 1, tm + 1, tr));
        t[v] = merge(t[v + v], t[v + v + 1]);
        return res;
    }
};

lazy_segment_tree<int> tree;

const int inf = 1e9 + 10;
const int N = 5e5 + 10;
int a[N];
int l[N], r[N], last[N];

int solve(int n, int m) {
    for (int i = 1; i <= n; i++) {
        tree.update(i, i, -tree.get(i, i));
    }
    for (int i = 1; i <= n; i++) {
        a[i]--;
    }
    for (int i = 0; i <= n; i++) {
        for (int j = max(0, a[i] - 3); j <= a[i] + 3; j++) {
            l[j] = r[j] = last[j] = 0;
        }
    }
    int ans = -inf;
    for (int i = 1; i <= n; i++) {
        tree.update(last[a[i]] + 1, i - 1, 1);
        last[a[i]] = i;

        for (int x = a[i]; l[x] != 0 && last[x] >= l[x]; x++) {
            tree.update(l[x], min(last[x], r[x]), -1);
            r[x + 1] = min(last[x], r[x]);
            l[x + 1] = l[x + 1] == 0 ? l[x] : l[x + 1];
            if (r[x + 1] == r[x]) {
                l[x] = r[x] = 0;
            } else {
                l[x] = r[x + 1] + 1;
            }
        }

        {
            int x = a[i] == 0 ? 1 : 0;
            if (l[x] == 0) {
                l[x] = r[x] = i;
            } else {
                r[x] = i;
            }
        }

        tree.update(i, i, 1 - (a[i] == 0 ? 1 : 0));
        ans = max(ans, tree.get(1, i));
//        for (int j = 1; j <= i; j++) {
//            cout << tree.get(j, j) << " ";
//        }
//        cout << "\n";
    }
    for (int i = 1; i <= n; i++) {
        a[i]++;
    }
    ans--;
    return ans;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif

    int t;
    cin >> t;
    while (t--) {
        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        cout << solve(n, m) << "\n";
    }

#ifdef LOCAL
    cout << "\nTime elapsed: " << double(clock()) / CLOCKS_PER_SEC << " s.\n";
#endif
}