#include <bits/stdc++.h>

using namespace std;

const int maxn = 5e4 + 5;

struct Tree {
    int dp0, dp1, lz0, lz1;
} aint[maxn * 4];

vector < int > t0[maxn], t1[maxn];

int n, m, type[maxn], s[maxn], d[maxn], dp[maxn], ans[maxn];

inline void setZero( int node ) {
    aint[ node ].dp0 = 0;
    aint[ node ].dp1 = 0;
    aint[ node ].lz0 = 0;
    aint[ node ].lz1 = 0;
}

void build( int node, int left, int right ) {
    if (left == right) {
        setZero( node );
        dp[ left ] = 0;
        return;
    }

    int middle = (left + right) / 2;

    build( node*2, left, middle );
    build( node*2+1, middle+1, right );

    setZero( node );
}

inline void propagation( int node, int left, int right ) {
    aint[ node ].dp0 += aint[ node ].lz0;
    aint[ node ].dp1 += aint[ node ].lz1;

    if (left == right) {
        aint[ node ].lz0 = aint[ node ].lz1 = 0;
        return;
    }

    aint[ node*2 ].lz0 += aint[ node ].lz0;
    aint[ node*2 ].lz1 += aint[ node ].lz1;

    aint[ node*2 + 1 ].lz0 += aint[ node ].lz0;
    aint[ node*2 + 1 ].lz1 += aint[ node ].lz1;

    aint[ node ].lz0 = aint[ node ].lz1 = 0;
}

void updateAll( int node, int left, int right, int x, int y, int t ) {
    propagation( node, left, right );

    if (x <= left && right <= y) {
        if (t == 0)
            aint[ node ].lz0++;
        else
            aint[ node ].lz1++;
        propagation( node, left, right );
        return;
    }

    int middle = (left + right) / 2;

    if (x <= middle)
        updateAll( node * 2, left, middle, x, y, t );
    if (y > middle)
        updateAll( node * 2 + 1, middle + 1, right, x, y, t );

    propagation( node*2, left, middle );
    propagation( node*2+1, middle+1, right );

    aint[ node ].dp0 = max( aint[ node * 2 ].dp0, aint[ node*2 + 1 ].dp0 );
    aint[ node ].dp1 = max( aint[ node * 2 ].dp1, aint[ node*2 + 1 ].dp1 );
}

void updateOne( int node, int left, int right, int pos, int val ) {
    if (left == right) {
        aint[ node ].dp0 = aint[ node ].dp1 = val;
        return;
    }

    int middle = (left + right) / 2;

    if (pos <= middle)
        updateOne( node*2, left, middle, pos, val );
    else
        updateOne( node*2+1, middle+1, right, pos, val );

    aint[ node ].dp0 = max( aint[ node * 2 ].dp0, aint[ node*2 + 1 ].dp0 );
    aint[ node ].dp1 = max( aint[ node * 2 ].dp1, aint[ node*2 + 1 ].dp1 );
}

int main()
{
    ios::sync_with_stdio( false );

    //freopen( "input", "r", stdin );
    //freopen( "output","w", stdout);

    int tests;
    char ch;

    cin >> tests;

    while (tests--) {

        cin >> n >> m;

        for (int i = 1; i <= m; i++) {
            cin >> ch;
            if (ch == 'D' || ch == 'M')
                type[ i ] = 0;
            else
                type[ i ] = 1;
        }

        for (int i = 1; i <= m; i++)
            cin >> s[ i ];
        for (int i = 1; i <= m; i++)
            cin >> d[ i ];

        for (int i = 1; i <= n; i++) {
            t0[ i ].clear();
            t1[ i ].clear();
        }

        for (int i = 1; i <= m; i++) {
            if (s[ i ] < d[ i ]) {
                if (type[ i ] == 0)
                    t0[ d[ i ] ].push_back( s[ i ] );
                else
                    t1[ d[ i ] ].push_back( s[ i ] );
            }
        }

        build( 1, 1, n );

        dp[ 1 ] = 0;
        for (int i = 2; i <= n; i++) {
            dp[ i ] = dp[ i-1 ];
            for (auto x: t0[ i ])
                updateAll( 1, 1, n, 1, x, 0 );
            for (auto x: t1[ i ])
                updateAll( 1, 1, n, 1, x, 1 );

            dp[ i ] = max( dp[ i ], max( aint[ 1 ].dp0, aint[ 1 ].dp1 ) );

            updateOne( 1, 1, n, i, dp[ i ] );
        }

        memset( ans, 0, sizeof ans );
        for (int i = 1; i <= n; i++)
            if (ans[ dp[ i ] ] == 0)
                ans[ dp[ i ] ] = i;

        for (int i = m; i >= 1; i--)
            if (ans[ i ] == 0)
                ans[ i ] = ans[ i + 1 ];

        for (int i = 1; i <= m; i++) {
            if (ans[ i ] == 0)
                cout << "-1 ";
            else
                cout << ans[ i ] << " ";
        }

        cout << '\n';
    }

    return 0;
}