#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define test cout << " test " << endl
#define ff first
#define ss second
#define INF 1e18 + 10
const int k = 2e5 + 4;
ll tree[4 * k];
int n;
ll a[200005];
unordered_map<ll, ll> mp;
int solve(ll node, ll l, ll r)
{

    if (l == r)
        return tree[node] = mp[a[l]];

    ll mid = (l + r) / 2;
    ll x = 2 * node;
    ll y = 2 * node + 1;
    tree[node] = min(solve(x, l, mid), solve(y, mid + 1, r));
    return tree[node];
}

int query(ll node, ll l, ll r, ll l1, ll r1)
{
    if (l1 > r || r1 < l)
        return 1e+10;
    if (l1 <= l and r1 >= r)return tree[node];
    ll mid = (l + r) / 2;
    ll x = node * 2;
    ll y = x + 1;
    ll ans = min(query(x, l, mid, l1, r1), query(y, mid + 1, r, l1, r1));
    return ans;
}
int main()
{
    int cs = 0;
    ll m;
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%lld", &n);
        mp.clear();
        vector<ll> v, dp[n + 2], dp1[n + 2];
        for (int i = 1; i <= n; i++)
        {
            scanf("%lld", &a[i]);
            v.pb(a[i]);
        }
        sort(v.begin(), v.end());
        ll sum = 0;
        for (auto i : v)
        {
            if (mp[i] == 0)
            {
                sum++;
                mp[i] = sum;
            }
        }
        solve(1, 1, n);
        sum = 0;
        for (int i = 1; i <= n; i++)
        {
            sum = max(sum, mp[a[i]]);
            dp[sum].pb(i);
        }
        ll cnt = 0;
        sum = 0;
        for (int i = n; i >= 1; i--)
        {
            sum = max(sum, mp[a[i]]);
            dp1[sum].pb(i);
        }
        for (ll i = 2; i < n; i++)
        {
            ll x = mp[a[i]];
            if (dp[x].size())
            {
                auto tp = lower_bound(dp[x].begin(), dp[x].end(), i - 1);
                if (tp == dp[x].end())
                    tp--;
                ll k = *tp;
                if (k != i and dp1[x].size())
                {
                    if (dp1[x].size() >= 2)
                    {
                        if (dp1[x][0] > dp1[x][1])
                            reverse(dp1[x].begin(), dp1[x].end());
                    }
                    auto tk = upper_bound(dp1[x].begin(), dp1[x].end(), i);
                    if (tk == dp1[x].end())
                        tk--;
                    ll k1 = *tk;
                    if (k1 > i)
                    {
                        ll p = query(1, 1, n, *tp + 1, *tk - 1);
                        if (p == x)
                        {
                            printf("YES\n");
                            printf("%lld %lld %lld\n", *tp, *tk - 1 - *tp, n - *tk + 1);
                            cnt = 1;
                            break;
                        }
                    }
                }
            }
        }
        if (cnt == 0)
        {
            printf("NO\n");
        }
    }
}
