#include <bits/stdc++.h>
#include <algorithm>
#include <set>
#ifdef LOCAL
#include "debug.h"
#else
#define deb(...) 114514
#endif
using namespace std;
using LL = long long;
using pii = pair<int, int>;
using pll = pair<LL, LL>;
const int INF = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int N = 5e5;
#define int LL
template <typename T>
struct Fenwick {
    int n;
    vector<int> tree;
    Fenwick(int n = 0)
    {
        init(n);
    }
    void init(int n)
    {
        this->n = n;
        tree.assign(n + 1, T());
    }

    void add(int x, T v)
    {
        for (int i = x; i <= n; i += i & -i) {
            tree[i] += v;
        }
    }

    T sum(int x)
    {
        auto ans = T();
        for (int i = x; i > 0; i -= i & -i) {
            ans += tree[i];
        }
        return ans;
    }

    T rangeSum(int l, int r)
    {
        return sum(r) - sum(l - 1);
    }

    int kth(T k)
    {
        assert(k > 0);
        int x = 1;
        for (int i = 1 << __lg(n); i; i /= 2) {
            if (x + i <= n && k > tree[x + i - 1]) {
                x += i;
                k -= tree[x - 1];
            }
        }
        return x;
    }
    void clear()
    {
        for (int i = 1; i <= n; i++)
            tree[i] = T();
    }
};
template <class Info, class Tag>
struct LazySegmentTree {
    int n;
    vector<Info> info;
    vector<Tag> tag;
    LazySegmentTree() : n(0) {}
    LazySegmentTree(int n_, Info v_ = Info())
    {
        init(vector<Info>(n_ + 1, v_));
    }
    LazySegmentTree(vector<Info> t_)
    {
        init(t_);
    }
    void init(vector<Info> a)  //[1,n]
    {
        n = a.size() - 1;
        info.assign((n << 2) + 1, Info());
        tag.assign((n << 2) + 1, Tag());
        function<void(int, int, int)> build = [&](int x, int l, int r) -> void {
            if (l == r) {
                info[x] = a[l];
                return;
            }
            int mid = l + r >> 1;
            build(x << 1, l, mid);
            build(x << 1 | 1, mid + 1, r);
            pull(x);
        };
        build(1, 1, n);
    }
    void pull(int x)
    {
        info[x] = info[x << 1] + info[x << 1 | 1];
    }
    void apply(int p, const Tag& v)
    {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int x)
    {
    }
    void update(int x, int l, int r, int p, const Info& v)
    {
        if (l == r) {
            info[x] = v;
            return;
        }
        int mid = l + r >> 1;
        push(x);
        if (p <= mid)
            update(x << 1, l, mid, p, v);
        else
            update(x << 1 | 1, mid + 1, r, p, v);
        pull(x);
    }
    void update(int p, const Info& v)
    {
        update(1, 1, n, p, v);
    }
    Info query(int x, int l, int r, int ql, int qr)
    {
        if (l > qr || r < ql)
            return Info();
        if (ql <= l && r <= qr)
            return info[x];
        int mid = l + r >> 1;
        push(x);
        return query(x << 1, l, mid, ql, qr) + query(x << 1 | 1, mid + 1, r, ql, qr);
    }
    Info query(int ql, int qr)
    {
        return query(1, 1, n, ql, qr);
    }
    void rangeupdate(int x, int l, int r, int ql, int qr, const Tag& v)
    {
        if (l > qr || r < ql)
            return;
        if (ql <= l && r <= qr) {
            apply(x, v);
            return;
        }
        int mid = l + r >> 1;
        push(x);
        rangeupdate(x << 1, l, mid, ql, qr, v);
        rangeupdate(x << 1 | 1, mid + 1, r, ql, qr, v);
        pull(x);
    }
    void rangeupdate(int ql, int qr, const Tag& v)
    {
        rangeupdate(1, 1, n, ql, qr, v);
    }
    template <class F>
    int findFirst(int x, int l, int r, int ql, int qr, F pred)
    {
        if (l > qr || r < ql || !pred(info[x]))
            return -1;
        if (l == r)
            return l;
        int mid = l + r >> 1;
        push(x);
        int res = findFirst(x << 1, l, mid, ql, qr, pred);
        if (res == -1)
            res = findFirst(x << 1 | 1, mid + 1, r, ql, qr, pred);
        return res;
    }
    template <class F>
    int findFirst(int l, int r, F pred)
    {
        return findFirst(1, 1, n, l, r, pred);
    }
    void clear(int x, int l, int r)
    {
        if (l == r) {
            info[x] = Info();
            return;
        }
        int mid = l + r >> 1;
        clear(x << 1, l, mid);
        clear(x << 1 | 1, mid + 1, r);
    }
};
struct Tag {
    void apply(const Tag& v)
    {
    }
};
struct Info {
    int mn = 0;
    void apply(const Tag& v)
    {
    }
};
Info operator+(const Info& a, const Info& b)
{
    Info c = Info();
    c.mn = min(a.mn, b.mn);
    return c;
}
const int NN = 5e5;
// Fenwick<int> Tree(NN + 1);
LazySegmentTree<Info, Tag> tree(NN);
Fenwick<int>Tree(NN);
void solve()
{
    int n, m;
    cin >> n >> m;
    vector<int> a(n + 1);
    vector<int> pre(n + 1, 0);
    vector<int> nxt(n + 1, n + 1);
    map<int, int>pos;
    vector<int> b;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        pre[i] = pos[a[i]];
        pos[a[i]] = i;
    }
    for (auto& [_, v] : pos)v = n + 1;
    for (int i = n; i >= 1; i--) {
        nxt[i] = pos[a[i]];
        pos[a[i]] = i;
    }
    vector<array<int, 2>> q;
    deb(pre, nxt);
    for (int i = 1; i <= n; i++) {
        if (i - 1 >= pre[i] + 1)
            q.push_back({ pre[i] + 1, i - 1 });
        if (nxt[i] - 1 >= i + 1)
            q.push_back({ i + 1, nxt[i] - 1 });
    }
    q.push_back({ 1,n });
    sort(q.begin(), q.end(), [&](const auto& x, const auto& y) {
        return x[1] < y[1];
    });
    // assert(q.size()<=2*n);
    // deb(q);
    int j = 0;
    int ans = -INF;
    vector<int>P(n + 1);
    for (auto [l, r] : q) {
        // auto [l,r]=p;
        int res = 0;
        while (j + 1 <= r) {
            j++;
            if (pre[j] != 0)
                Tree.add(pre[j], -1), P[pre[j]] = 0;
            Tree.add(j, 1);
            P[j] = 1;
            tree.update(a[j], Info{ j });
        }
        res = Tree.rangeSum(l, r) - tree.findFirst(1, NN, [&](const Info& v) { return v.mn <= l - 1; });
        deb(res);
        ans = max(res, ans);
    }
    for (int i = 1; i <= n; i++)tree.update(a[i], Info{ 0 });
    for (int i = 1; i <= n; i++)if (P[i])Tree.add(i, -1);
    cout << ans << "\n";
}
signed main()
{
#ifdef LOCAL
    clock_t tttttttt = clock();
#endif
#ifndef LOCAL
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#endif
    //*****************************************************************
    int t = 1;
    cin >> t;
    while (t--) solve();
    //*****************************************************************
#ifdef LOCAL
    cerr << "Time Used: " << fixed << setprecision(3) << (clock() - tttttttt) / (CLOCKS_PER_SEC / 1000.0) << " ms" << endl;
#endif
    return 0;
}