#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#include <bits/stdc++.h>

using std::cerr;
using std::cin;
using std::cout;

using std::abs;
using std::min;
using std::max;
using std::swap;

using std::map;
using std::pair;
using std::set;
using std::string;
using std::vector;

using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

#define ff first
#define ss second
#define pb emplace_back
template<typename T> 
void _dbg(const char* _s, T _h) {
    cerr << _s << " = " << _h <<"\n"; 
}
template<typename T, typename... Ts>
void _dbg(const char* _s, T _h, Ts... _t) {
    int _b = 0;
    while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',')
        cerr << *_s++; 
    cerr << " = " << _h << ","; 
    _dbg(_s+1, _t...);
}
#ifdef LOCAL
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...) 
#endif

struct init {
    init() {
        cin.tie(0);
        std::iostream::sync_with_stdio(0);
        cout << std::fixed << std::setprecision(10);
        cerr << std::fixed << std::setprecision(5);
        #ifdef LOCAL
        srand(300); 
        #else
        using namespace std::chrono;
        srand(duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count()); 
        #endif
    }
    ~init() {
        #ifdef LOCAL
        cerr << "Time elapsed: " << (double)clock() / CLOCKS_PER_SEC << "s.\n";
        #endif
    }
} init;

const int MAXN = 50017;
char t[MAXN];
int s[MAXN];
int f[MAXN];
vector<int> reds[MAXN];
vector<int> blus[MAXN];
int dp[MAXN];
#define _dump(x) {string _f;std::stringstream _fs;_fs<<#x<<" = "<<(x);getline(_fs,_f);_fields.pb(_f);}
vector<string> _pretty(vector<string> _fields) {
    vector<string>_res;size_t _width=0;for (auto&_i:_fields)_width = max(_width, _i.size());string _border;while(_border.size()<_width)
    _border+='_';_fields.pb(_border);_res.pb(" "+_border+" ");for(auto&_i:_fields){size_t _tol=_width-_i.size()>>1;size_t _tor=_width-
    _i.size()+1>>1;string _sl,_sr;while(_sl.size()<_tol)_sl+=' ';while(_sr.size()<_tor)_sr+=' ';_res.pb("|"+_sl+_i+_sr+"|");}return _res;
}
vector<string> str(int v, int m) {
    vector<string> _fields;
    _dump(v);
    _dump(m);
    return _pretty(_fields);
}
struct segment_tree {
    vector<int> tree, mod;
    int n, sh = 1;
    segment_tree() {}
    segment_tree(int _n) : n(_n) {
        while (sh < n)
            sh *= 2;
        tree.resize(2 * sh, 0);
        mod.assign(2 * sh, 0);
    }

    void push(int v, int tl, int tr) {
        if (tl == tr) {
            tree[v] += mod[v];
            mod[v] = 0;
            return;
        }
        mod[v + v] += mod[v];
        mod[v + v + 1] += mod[v];
        tree[v] += mod[v];
        mod[v] = 0;
    }

    int get(int v, int tl, int tr, int l, int r) {
        if (l > tr || r < tl)
            return 0;
        push(v, tl, tr);
        if (l <= tl && tr <= r) 
            return tree[v];
        int tm = tl + tr >> 1;
        return max(get(v + v, tl, tm, l, r),
               get(v + v + 1, tm + 1, tr, l, r));
    }

    void add(int v, int tl, int tr, int l, int r) {
        if (l > tr || r < tl) {
            // sometimes u need push here
            push(v, tl, tr);
            return;
        }
        if (l <= tl && tr <= r) {
            mod[v]++;
            push(v, tl, tr);
            return;
        }
        push(v, tl, tr);
        int tm = tl + tr >> 1;
        add(v + v, tl, tm, l, r);
        add(v + v + 1, tm + 1, tr, l, r);
        tree[v] = max(tree[v + v], tree[v + v + 1]);
    }

    void single(int v, int tl, int tr, int x, int val) {
        if (x > tr || x < tl) {
            // sometimes u need push here
            return;
        }
        if (tl == tr) {
            tree[v] = max(tree[v], val);
            return;
        }
        push(v, tl, tr);
        int tm = tl + tr >> 1;
        if (x <= tm)
            single(v + v, tl, tm, x, val);
        else 
            single(v + v + 1, tm + 1, tr, x, val);
        tree[v] = max(tree[v + v], tree[v + v + 1]);        
    }

    int top() {
        return get(1, 0, sh - 1, 0, sh - 1);
    }

    void add(int l, int r) {
        add(1, 0, sh - 1, l, r);
    }
    void single(int l, int r) {
        single(1, 0, sh - 1, l, r);
    }

    int get(int l, int r) {
        return get(1, 0, sh - 1, l, r);
    }

    vector<string> print(int v, int tl, int tr) {if(tl==tr)return str(tree[v],mod[v]);int tm=tl+tr>>1;vector<string> _lts=print(v*2,tl,tm),_md=
    str(tree[v],mod[v]),_rts=print(v*2+1,tm+1,tr);size_t _szl=_lts[0].size();size_t _szr=_rts[0].size();_lts[0][_szl>>1]=_rts[0][_szr>>1]='|';
    string _ft,_sd;size_t _pl=(_szl>>1)+1,_pr=_szl+(_szr>>1);for(size_t i=0;i<_szl+_szr+1;++i){if(_pl<=i&&i<=_pr)_sd += '_';else _sd +=
    ' ';}while(_ft.size()<_sd.size())_ft+=' ';size_t _width=_szl+_szr+1;size_t _pos1=_width-1>>1,_pos2=(_pl+_pr)>>1;_ft[_pos1]=_sd[_pos2]=
    '|';if(_pos1<_pos2)for(size_t i=0;i<_width;++i)if(_pos1<i&&i<=_pos2)_ft[i]='_';if(_pos2<_pos1)for(size_t i=0;i<_width;++i)if(_pos2<=
    i&&i<_pos1)_ft[i]='_';while(_md[0].size()+2<=_width)for(auto&i:_md)i=" "+i+" ";if(_md[0].size()<_width)for(auto&i:_md)i+=" ";
    vector<string> _res=_md;_res.pb(_ft);_res.pb(_sd);for(int i=0;i<(int)_lts.size();++i)_res.pb(_lts[i]+" "+_rts[i]);return _res;}
    void print(){
        #ifdef LOCAL
        auto _pr=print(1,0,sh - 1);for(auto i:_pr)cerr<<i<<'\n';
        #endif
    }
};
int main() {
    int tt;
    cin >> tt;
    while (tt--) {
        int n, m;
        cin >> m >> n;
        for (int i = 0; i <= m; ++i) {
            reds[i].clear();
            blus[i].clear();
        }
        for (int i = 0; i < n; ++i) {
            char c;
            cin >> c;
            t[i] = c == 'D' || c == 'M';
        }
        for (int i = 0; i < n; ++i)
            cin >> s[i];
        for (int i = 0; i < n; ++i) {
            cin >> f[i];
            if (s[i] < f[i]) {
                if (t[i])
                    reds[f[i]].pb(s[i]);
                else
                    blus[f[i]].pb(s[i]);
            }
        }
        for (int i = 0; i <= m; ++i) dp[i] = 0;
        segment_tree rst(m + 2), bst(m + 2);
        for (int i = 1; i <= m; ++i) {
            for (int j : reds[i])
                rst.add(0, j);
            for (int j : blus[i])
                bst.add(0, j);
            int cur = max(rst.top(), bst.top());
            rst.single(i, cur);
            bst.single(i, cur);
            dbg(i, cur);
            dp[i] = cur;
            dbg("rst");
            rst.print();
            dbg("bst");
            bst.print();
        }
        for (int i = 1; i <= n; ++i) {
            int it = std::lower_bound(dp, dp + m + 1, i) - dp;
            if (it == m + 1)
                it = -1;
            cout << it << ' ';
        }
        cout << '\n';
    }

    return 0;
}