#include "bits/stdc++.h"
using namespace std;

#define debug(args...) fprintf(stderr, args);

const int maxn = 5e4 + 10;

int t;

int n, m;

char type[maxn];
int s[maxn], d[maxn];

struct node {
    int dp, lazy;
} seg[2][4 * maxn];

void build(int id, int idx, int i, int j) {
    seg[id][idx].dp = seg[id][idx].lazy = 0;

    if(i == j)
	return;

    int mid = (i + j) >> 1;
    int left = idx << 1;
    int right = left | 1;

    build(id, left, i, mid);
    build(id, right, mid + 1, j);
}

void refresh(int id, int idx, int i, int j) {
    int left = idx << 1;
    int right = left | 1;

    if(i != j) {
	seg[id][left].lazy += seg[id][idx].lazy;
	seg[id][right].lazy += seg[id][idx].lazy;
    }

    seg[id][idx].dp += seg[id][idx].lazy;
    seg[id][idx].lazy = 0;
}

void update(int id, int idx, int i, int j, int l, int r, int val) {
    refresh(id, idx, i, j);
    
    if(i > j || j < l || r < i)
	return;

    if(l <= i && j <= r) {
	seg[id][idx].lazy += val;
	refresh(id, idx, i, j);
	return;
    }

    int mid = (i + j) >> 1;
    int left = idx << 1;
    int right = left | 1;

    update(id, left, i, mid, l, r, val);
    update(id, right, mid + 1, j, l, r, val);

    seg[id][idx].dp = max(seg[id][left].dp, seg[id][right].dp);
}

int query(int id, int idx, int i, int j, int l, int r) {
    refresh(id, idx, i, j);

    if(i > j || j < l || r < i)
	return 0;

    if(l <= i && j <= r)
	return seg[id][idx].dp;

    int mid = (i + j) >> 1;
    int left = idx << 1;
    int right = left | 1;

    return max(query(id, left, i, mid, l, r), query(id, right, mid + 1, j, l, r));
}

vector<int> ranges[2][maxn];

int dp[maxn];

void processDogAndMice() {
    for(int i = 1; i <= n; ++i)
	if(type[i] == 'D' || type[i] == 'M')
	    if(s[i] < d[i])	
		ranges[0][d[i]].push_back(s[i]);

    build(0, 1, 1, m);
}

void processElephantAndCat() {
    for(int i = 1; i <= n; ++i)
	if(type[i] == 'E' || type[i] == 'C')
	    if(s[i] < d[i])
		ranges[1][d[i]].push_back(s[i]);

    build(1, 1, 1, m);
}

void lineSweep() {
    for(int r = 1; r <= m; ++r) {
	for(int k = 0; k <= 1; ++k)
	    while(!ranges[k][r].empty()) {
		int l = ranges[k][r].back();

		ranges[k][r].pop_back();
		update(k, 1, 1, m, 1, l, +1);
	    }

	dp[r] = max(query(0, 1, 1, m, 1, r), query(1, 1, 1, m, 1, r));
	update(0, 1, 1, m, r, r, dp[r]);
	update(1, 1, 1, m, r, r, dp[r]);
    }
}

int ans[maxn];

void calcAns() {
    for(int i = 1; i <= n; ++i)
	ans[i] = INT_MAX;

    for(int i = 1; i <= m; ++i)
	ans[dp[i]] = min(ans[dp[i]], i);
    
    for(int i = n - 1; i >= 1; --i)
	ans[i] = min(ans[i], ans[i + 1]);
    
    for(int i = 1; i <= n; ++i)
	if(ans[i] == INT_MAX)
	    ans[i] = -1;
}

void solve() {
    processDogAndMice();
    processElephantAndCat();
    lineSweep();
    calcAns();
}

int main() {
    cin.sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin >> t;

    while(t--) {
	cin >> m >> n;

	for(int i = 1; i <= n; ++i)
	    cin >> type[i];

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

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

	solve();

	for(int i = 1; i <= n; ++i) {
	    cout << ans[i];

	    if(i == n)
		cout << '\n';
	    else
		cout << " ";
	}
    }
    
    return 0;
}