#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void solve() {
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    vector<int> sorted_a = a;
    sort(sorted_a.begin(), sorted_a.end());
    sorted_a.erase(unique(sorted_a.begin(), sorted_a.end()), sorted_a.end());
    for (int& x : a) {
        x = lower_bound(sorted_a.begin(), sorted_a.end(), x) - sorted_a.begin();
    }

    int num_distinct = sorted_a.size();
    vector<int> blocks(num_distinct, 0);
    int bad_left = -1;
    vector<int> seen(num_distinct, 0);

    for (int i = 0; i < n; ++i) {
        if (i == 0 || a[i] != a[i - 1]) {
            blocks[a[i]]++;
            if (blocks[a[i]] >= 4) {
                cout << "NO\n";
                return;
            }
            if (bad_left == -1 && seen[a[i]]) {
                bad_left = i;
            }
            seen[a[i]] = 1;
        }
    }

    if (bad_left == -1) {
        cout << "YES\n";
        return;
    }

    int bad_right = -1;
    vector<int> seen2(num_distinct, 0);
    for (int i = n - 1; i >= 0; --i) {
        if (i == n - 1 || a[i] != a[i + 1]) {
            if (bad_right == -1 && seen2[a[i]]) {
                bad_right = i;
            }
            seen2[a[i]] = 1;
        }
    }

    int v = a[bad_left];
    int u = a[bad_right];

    auto get_candidates = [&](int val) {
        vector<int> c;
        int L = -1;
        for (int i = 0; i <= n; ++i) {
            if (i < n && a[i] == val) {
                if (L == -1) L = i;
            } else {
                if (L != -1) {
                    int R = i - 1;
                    for (int x : {L - 1, L, L + 1, R - 1, R, R + 1}) {
                        if (x >= 0 && x < n) c.push_back(x);
                    }
                    L = -1;
                }
            }
        }
        return c;
    };

    vector<int> cand;
    vector<int> cv = get_candidates(v);
    vector<int> cu = get_candidates(u);
    cand.insert(cand.end(), cv.begin(), cv.end());
    cand.insert(cand.end(), cu.begin(), cu.end());

    sort(cand.begin(), cand.end());
    cand.erase(unique(cand.begin(), cand.end()), cand.end());

    int token = 0;
    vector<int> seen_check(num_distinct, 0);
    auto check = [&](const vector<int>& arr) {
        token++;
        for (int i = 0; i < n; ++i) {
            if (i > 0 && arr[i] == arr[i - 1]) continue;
            if (seen_check[arr[i]] == token) return false;
            seen_check[arr[i]] = token;
        }
        return true;
    };

    for (int i = 0; i < cand.size(); ++i) {
        for (int j = i + 1; j < cand.size(); ++j) {
            if (a[cand[i]] == a[cand[j]]) continue;
            swap(a[cand[i]], a[cand[j]]);
            if (check(a)) {
                cout << "YES\n";
                return;
            }
            swap(a[cand[i]], a[cand[j]]);
        }
    }
    cout << "NO\n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    if (cin >> t) {
        while (t--) {
            solve();
        }
    }
    return 0;
}