#include <bits/stdc++.h>

#define taskname "test"

using namespace std;

typedef long long LL;

const int maxtest = 10;
const int maxn = 50000 + 7;
const int maxm = 50000 + 7;
const int news = 3;

struct seg {
    int lazy, f;
};

int ntest, m, n, n0, n1;
int c[maxn], s[maxn], t[maxn], cs[2][maxn], x[maxn];
int f[maxm], cnt[2][maxm];
seg IT[2][maxm * news];
int BIT[2][maxm];

template <typename T> inline void read(T &x){
    x = 0; char ch; int positive = 1;
    while (!isdigit(ch = getchar())) if (ch == '-') positive = 0;
    do x = x * 10 + ch - '0'; while (isdigit(ch = getchar()));
    if (!positive) x = -x;
}

void input() {
    read(m);read(n);
    for(int i = 1; i <= n; ++i) {
        char ch;
        cin >> ch;
        if (ch == 'E' || ch == 'C') c[i] = 0; else c[i] = 1;
    }
    for(int i = 1; i <= n; ++i) read(s[i]);
    for(int i = 1; i <= n; ++i) read(t[i]);
}

bool cmp(int i, int j) {
    if (t[i] != t[j]) return t[i] < t[j];
    return s[i] > s[j];
}

void init() {
    n0 = n1 = 0;
    for(int i = 1; i <= n; ++i) {
        //if (s[i] > t[i]) swap(s[i], t[i]);
        if (c[i] == 0) {
            if (s[i] < t[i]) cs[0][++n0] = i;
        }
        else {
            if (s[i] < t[i]) cs[1][++n1] = i;
        }
    }
    sort(cs[0] + 1, cs[0] + 1 + n0, cmp);
    sort(cs[1] + 1, cs[1] + 1 + n1, cmp);
}

void pushIT(int k, int cs, bool leaf) {
    if (IT[k][cs].lazy == 0) return;
    IT[k][cs].f += IT[k][cs].lazy;
    if (!leaf) {
        IT[k][cs * 2].lazy += IT[k][cs].lazy;
        IT[k][cs * 2 + 1].lazy += IT[k][cs].lazy;
    }
    IT[k][cs].lazy = 0;
}

void incIT(int k, int cs, int d, int c, int u, int v) {
    pushIT(k, cs, d == c);
    if (v < d || c < u) return;
    if (u <= d && c <= v) {
        IT[k][cs].lazy += 1;
        pushIT(k, cs, d == c);
        return;
    }
    int mid = (d + c) >> 1;
    incIT(k, cs * 2, d, mid, u, v);
    incIT(k, cs * 2 + 1, mid + 1, c, u, v);
    IT[k][cs].f = max(IT[k][cs * 2].f, IT[k][cs * 2 + 1].f);
}

void updateIT(int k, int cs, int d, int c, int u, int v) {
    pushIT(k, cs, d == c);
    if (u < d || c < u) return;
    if (d == c) {
        IT[k][cs].f = v;
        return;
    }
    int mid = (d + c) >> 1;
    updateIT(k, cs * 2, d, mid, u, v);
    updateIT(k, cs * 2 + 1, mid + 1, c, u, v);
    IT[k][cs].f = max(IT[k][cs * 2].f, IT[k][cs * 2 + 1].f);
}

int queryIT(int k, int cs, int d, int c, int u, int v) {
    pushIT(k, cs, d == c);
    if (v < d || c < u) return 0;
    if (u <= d && c <= v) return IT[k][cs].f;
    int mid = (d + c) >> 1;
    int tg1 = queryIT(k, cs * 2, d, mid, u, v);
    int tg2 = queryIT(k, cs * 2 + 1, mid + 1, c, u, v);
    return max(tg1, tg2);
}

void updateBIT(int k, int i) {
    while (i <= m) {
        BIT[k][i] += 1;
        i += i & (-i);
    }
}

int queryBIT(int k, int i) {
    int res = 0;
    while (i) {
        res += BIT[k][i];
        i -= i & (-i);
    }
    return res;
}

void NewL() {
    for(int i = 1; i <= n; ++i) x[i] = m + 1;
    memset(f, 0, sizeof(f));
    memset(cnt, 0, sizeof(cnt));
    memset(IT, 0, sizeof(IT));
    memset(BIT, 0, sizeof(BIT));
    int k0 = 1, k1 = 1;
    for(int i = 1; i <= m; ++i) {
        while (k0 <= n0 && t[cs[0][k0]] <= i) {
            int z = cs[0][k0++];
            f[i] = max(f[i], f[s[z]] + 1);
            /*
            ++cnt[0][s[z]];
            int sum = 0;
            for(int j = i; j >= 0; --j) {
                sum += cnt[0][j];
                f[i] = max(f[i], f[j] + sum);
            }*/
            incIT(0, 1, 1, m, 1, s[z]);
            int tmp = queryBIT(0, i) - queryBIT(0, s[z]);
            tmp = queryIT(0, 1, 1, m, 1, i);
            f[i] = max(f[i], tmp);
            updateBIT(0, s[z]);
        }
        while (k1 <= n1 && t[cs[1][k1]] <= i) {
            int z = cs[1][k1++];
            f[i] = max(f[i], f[s[z]] + 1);
            /*
            ++cnt[1][s[z]];
            int sum = 0;
            for(int j = i; j >= 0; --j) {
                sum += cnt[1][j];
                f[i] = max(f[i], f[j] + sum);
            }*/
            incIT(1, 1, 1, m, 1, s[z]);
            int tmp = queryBIT(1, i) - queryBIT(1, s[z]);
            tmp = queryIT(1, 1, 1, m, 1, i);
            f[i] = max(f[i], tmp);
            updateBIT(1, s[z]);
        }
        f[i] = max(f[i], f[i - 1]);
        updateIT(0, 1, 1, m, i, f[i]);
        updateIT(1, 1, 1, m, i, f[i]);
        x[f[i]] = min(x[f[i]], i);
    }
    for(int i = n - 1; i >= 1; --i) x[i] = min(x[i], x[i + 1]);
    for(int i = 1; i <= n; ++i)
    if (x[i] <= m) printf("%d ", x[i]); else printf("%d ", -1);
    puts("");
}

void solve() {
    input();
    init();
    NewL();
}

int main() {
    //freopen(taskname".inp","r",stdin);
	//freopen(taskname".out","w",stdout);
	read(ntest);
	for(int itest = 1; itest <= ntest; ++itest) solve();
	return 0;
}