#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <tuple>
#include <utility>
#define greedy int
#define mindset main()

using namespace std;
#define FOR(a,b,c) for(int a = b; a < (c); a++)
#define FORR(a,b,c) for(int a = b; a > (c); a--)
 
#define READ(x) long long x;cin>>x;
#define READAR(x,n) vll x(n); FOR(readar,0,n) cin >> x[readar];

#define speedfirst ios_base::sync_with_stdio(false); cin.tie(NULL); 
 
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<ll,ll> pll;
typedef vector<pll> vpll;
typedef tuple<ll,ll,ll> tll;

ll MOD = 998244353;

/*//Combinatorics mod MOD
vll FACT(1e5);

ll fastexp(ll a, ll p) {
    ll r = 1;
    while(p) {
        if(p&1) r = r*a % MOD;
        a = a*a % MOD;
        p >>= 1;
    }
    return r;
}

ll modinv(ll x) {
    return fastexp(x,MOD-2);
}

void DOFACTS() {
    FACT[0] = 1;
    FOR(i,1,FACT.size()) {
        FACT[i] = i*FACT[i-1] % MOD;
    }
}

ll gcd(ll a, ll b) {
   if (b == 0)
   return a;
   return gcd(b, a % b);
}
*/

//segment tree, courtesy of https://cp-algorithms.com/data_structures/segment_tree.html
/*
int tree[4*200000];
void build(int v, int tl, int tr) {
    if (tl == tr) {
        tree[v] = 0;
    } else {
        int tm = (tl + tr) / 2;
        build(v*2, tl, tm);
        build(v*2+1, tm+1, tr);
        tree[v] = tree[v*2] + tree[v*2+1];
    }
}
int sum(int v, int tl, int tr, int l, int r) {
    if (l > r) 
        return 0;
    if (l == tl && r == tr) {
        return tree[v];
    }
    int tm = (tl + tr) / 2;
    return sum(v*2, tl, tm, l, min(r, tm))
           + sum(v*2+1, tm+1, tr, max(l, tm+1), r);
}
void update(int v, int tl, int tr, int pos, int new_val) {
    if (tl == tr) {
        tree[v] = new_val;
    } else {
        int tm = (tl + tr) / 2;
        if (pos <= tm)
            update(v*2, tl, tm, pos, new_val);
        else
            update(v*2+1, tm+1, tr, pos, new_val);
        tree[v] = tree[v*2] + tree[v*2+1];
    }
}
void add(int v, int tl, int tr, int pos, int new_val) {
    if (tl == tr) {
        tree[v] += new_val;
    } else {
        int tm = (tl + tr) / 2;
        if (pos <= tm)
            add(v*2, tl, tm, pos, new_val);
        else
            add(v*2+1, tm+1, tr, pos, new_val);
        tree[v] = tree[v*2] + tree[v*2+1];
    }
}
*/


greedy mindset {
    speedfirst;

    READ(T);
    FOR(t,0,T) {
        READ(N); READAR(A, N);
        map<ll,vll> CA;

        FOR(i,0,N) {
            CA[A[i]].push_back(i);
        }

        if(CA[A[0]].size() == N) {
            cout << "NO\n"; continue;
        }

        vll X(N);
        FOR(i,0,N) X[i] = i+1;

        sort(X.begin(), X.end(), [&](ll x, ll y) {
            return (CA[x].size() > CA[y].size()) || ((CA[x].size() == CA[y].size()) && (x > y));
        });

        vll P(N,-1);

        FOR(i,0,N) {
            if(!(CA[i].size())) CA.erase(i);
        }

        FOR(i,0,N) {
            auto it = CA.begin();
            if((*it).first == X[i]) ++it;
            P[(*it).second.back()] = X[i];
            (*it).second.pop_back();
            if(!(*it).second.size()) {
                CA.erase(it);
            }
        }

        cout << "YES\n";

        FOR(i,0,N) {
            cout << P[i] << (i == N-1 ? '\n' : ' ');
        }

        
    }
}