#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i<= b; ++i)
#define FORD(i, a, b) for (int i = a; i>=b; --i)
#define REP(i, a) for (int i = 0; i<a; ++i)
#define N 100100
#define pp pair<int, int>
#define bit(S, i) (((S) >> i) & 1)
#define IO ios::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
#define taskname ""
using namespace std;

int n, m;
char a[N];
int d[N], s[N];
vector<int> last[N];
int f[N], dp[2][N];
int BIT[2][N], BIT2[2][N];
void UpBIT(int k, int u, int val) {
    for(; u <= m; u += u&-u) BIT[k][u] = max(BIT[k][u], val);
}

int GetBIT(int k, int u) {
    int ans = 0;
    for(; u > 0; u -= u&-u) ans = max(ans, BIT[k][u]);
    return ans;
}

void UpBIT2(int k, int u) {
    for(; u > 0; u -= u&-u) BIT2[k][u]++;
}

int GetBIT2(int k, int u) {
    int ans = 0;
    for(; u <= m; u += u&-u) ans += BIT2[k][u];
    return ans;
}

int IT[2][N * 4], lazy[2][N * 4];
void Down(int z, int k) {
    if (lazy[z][k] == 0) return;
    IT[z][k * 2] += lazy[z][k];
    IT[z][k * 2 + 1] += lazy[z][k];
    lazy[z][k * 2] += lazy[z][k];
    lazy[z][k * 2 + 1] += lazy[z][k];
    lazy[z][k] = 0;
}

void Add(int z, int k, int l, int r, int u, int v) {
    if (l > v || r < u) return;
    if (u <= l && r <= v) {
        IT[z][k]++;
        lazy[z][k]++;
        return;
    }
    Down(z, k);
    int m = (l + r) >> 1;
    Add(z, k * 2, l, m, u, v);
    Add(z, k * 2 + 1, m + 1, r, u, v);
    IT[z][k] = max(IT[z][k * 2], IT[z][k * 2 + 1]);
}

void Up(int z, int k, int l, int r, int u, int val) {
    if (l == r) {
        IT[z][k] = max(IT[z][k], val);
        return;
    }
    Down(z, k);
    int m = (l + r) >> 1;
    if (u <= m) Up(z, k * 2, l, m, u, val);
    else Up(z, k * 2 + 1, m + 1, r, u, val);
    IT[z][k] = max(IT[z][k * 2], IT[z][k * 2 + 1]);
}

int Get(int z, int k, int l, int r, int u, int v) {
    if (l > v || r < u) return 0;
    if (u <= l && r <= v) return IT[z][k];
    Down(z, k);
    int m = (l + r) >> 1;
    return max(Get(z, k * 2, l, m, u, v), Get(z, k * 2 + 1, m + 1, r, u, v));
}

void solve() {
    cin >> m >> n;
    FOR(i, 1, m) last[i].clear();
    REP(i, n) cin >> a[i];
    REP(i, n) cin >> s[i];
    REP(i, n) cin >> d[i];
    REP(i, n) if (s[i] < d[i]) last[d[i]].push_back(i);
    FOR(i, 1, m) {
        sort(last[i].begin(), last[i].end(), [] (const int &a, const int &b) {
            return s[a] > s[b];
        });
    }
    FOR(i, 1, n) f[i] = m + 1;
    FOR(i, 1, m) REP(j, 2) dp[j][i] = BIT[j][i] = BIT2[j][i] = 0;
    FOR(i, 1, m * 4) REP(j, 2) IT[j][i] = lazy[j][i] = 0;
    int cnt0 = 0, cnt1 = 0;
    FOR(i, 1, m) {
        dp[0][i] = dp[0][i - 1];
        dp[1][i] = dp[1][i - 1];
        for (int id : last[i]) {
            if (a[id] == 'E' || a[id] == 'C') { // 0
                UpBIT2(0, s[id]);
                Add(0, 1, 1, m, 1, s[id]);
                cnt0++;
                int tmp = dp[1][s[id]] + GetBIT2(0, s[id]);
                tmp = max(tmp, Get(0, 1, 1, m, 1, s[id]));
                dp[0][i] = max(dp[0][i], tmp);
                Up(0, 1, 1, m, s[id], tmp);
            }
            else {
                cnt1++;
                UpBIT2(1, s[id]);
                Add(1, 1, 1, m, 1, s[id]);
                int tmp = dp[0][s[id]] + GetBIT2(1, s[id]);
                tmp = max(tmp, Get(1, 1, 1, m, 1, s[id]));
                dp[1][i] = max(dp[1][i], tmp);
                Up(1, 1, 1, m, s[id], tmp);
            }

        }
        int mx = max(dp[0][i], dp[1][i]);
        if (f[mx] == m + 1) f[mx] = i;
    }
    FORD(i, n - 1, 1) f[i] = min(f[i], f[i + 1]);
    FOR(i, 1, n) {
        if (f[i] == m + 1) f[i] = -1;
        cout<<f[i]<<' ';
    }
    cout<<'\n';
}
int main() {
    IO;
  //  freopen("Test.inp","r",stdin);
  //  freopen("Test.out","w",stdout);
    int test;
    cin >> test;
    while (test--) solve();
}