#include<iostream>
#include<algorithm>
#include<vector>
#include<cassert>
using namespace std;

#define sz(x) (int)(x.size())
#define fi(a,b) for(int i=a;i<b;++i)
#define fj(a,b) for(int j=a;j<b;++j)
#define fo(a,b) for(int o=a;o<b;++o)
#define fdi(a,b) for(int i=a-1;i>=b;--i)
#define fdj(a,b) for(int j=a-1;j>=b;--j)
#define fdo(a,b) for(int o=a-1;o>=b;--o)
#define pb push_back
#define mp make_pair
typedef pair<int, int> pii;
//////////////////////

int const N = 5e4 + 41;
int const INF = 1e9 + 41;

int m, n;
char c[N];
int s[N], d[N];
vector<pii> e[N];
int ans[N];
int f[N], h[N][2];

int gett(char c){
	return (c == 'E' || c == 'C' ? 0 : 1);
}

void clear(){
	fi(1, N) ans[i] = INF;
	fi(1, N) e[i].clear();
	fi(1, N) f[i] = -INF;
	fi(1, N) h[i][0] = h[i][1] = 0;
}

struct Node{
	int f, la;
	Node *l, *r;
	Node(){
		l = r = NULL;
		f = -INF;
		la = 0;
	}
	Node(Node *l, Node *r){
		f = -INF;
		la = 0;
		this->l = l;
		this->r = r;
	};
	void push(){
		if(la){
			if(l) l->la += la;
			if(r) r->la += la;
			f += la;
			la = 0;
		}
	}
	void refresh(){
		assert(l != NULL && r != NULL);
		f = max(f, l->f + l->la);
		f = max(f, r->f + r->la);
	}
};

struct Tree{
#ifdef _DEBUG
	Node *t[(1 << 7)];
#else
	Node *t[(1 << 17)];
#endif
	int l, r, p, val;
	int n;
	Tree(){};

	void build(int v, int tl, int tr){
		if(tl == tr){
			t[v] = new Node();
			if(tl == 0) t[v]->f = 0;
		}else{
			int tm = (tl+tr)/2;
			build(v*2+1, tl, tm);
			build(v*2+2, tm+1, tr);
			t[v] = new Node(t[v*2+1], t[v*2+2]);
			t[v]->refresh();
			//printf("%d %d %d %d\n",&t[v*2+1],t[v].l,&t[v*2+2],t[v].r);
		}
	}

	Tree(int n){
		this->n = n;
		build(0, 0, n);
	}

	void set(int v, int tl, int tr){
		t[v]->push();
		if(tl == tr){
			t[v]->f = val;
		}else{
			int tm = (tl+tr)/2;
			if(p <= tm) set(v*2+1, tl, tm);
			else set(v*2+2, tm+1, tr);
			t[v]->refresh();
			assert(t[v*2+1] == t[v]->l);
			assert(t[v*2+2] == t[v]->r);
		}
	}

	void set(int p, int val){
		this->val = val;
		this->p = p;
		set(0, 0, n);
	}

	void upd(int v, int tl, int tr){
		if(l > tr || tl > r) return;
		t[v]->push();
		if(l <= tl && tr <= r){
			++t[v]->la;
			t[v]->push();
			return;
		}
		int tm = (tl+tr)/2;
		upd(v*2+1, tl, tm);
		upd(v*2+2, tm+1, tr);
		t[v]->refresh();
	}

	void upd(int l, int r){
		this->l = l;
		this->r = r;
		upd(0, 0, n);
	}

	int get(int v, int tl, int tr){
		if(l > tr || tl > r) return -INF;
		t[v]->push();
		if(l <= tl && tr <= r){
			return t[v]->f;
		}
		int tm = (tl+tr)/2;
		int v0 = get(v*2+1, tl, tm);
		int v1 = get(v*2+2, tm+1, tr);
		int v2 = max(v0, v1);
		t[v]->refresh();
		return v2;
	}

	int get(int l, int r){
		this->l = l;
		this->r = r;
		return get(0, 0, n);
	}
};

Tree t[2];

void solve(){
	clear();

	fi(0, n){
		if(s[i] > d[i]) continue;
		pii v = mp(s[i], gett(c[i]));
		e[d[i]].pb(v);
	}
	fi(0, 2) t[i] = Tree(m);
	fi(1, m+1){
		fj(0, sz(e[i])){
			int l = e[i][j].first;
			int t = e[i][j].second;
			//h[l][t] += 1;
			::t[t].upd(0, l);
		}
		/*fo(0, 2){
			int s = 0;
			fdj(i, 0){
				s += h[j][o];
				int x = f[j];
				f[i] = max(f[i], s + x);
			}
		}*/
		int x0 = t[0].get(0, i-1);
		int x1 = t[1].get(0, i-1);
		int x = max(x0, x1);
		f[i] = x;
		t[0].set(i, x);
		t[1].set(i, x);
	}
	
	fi(1, m+1){
		int x = f[i];
		if(x >= 0) ans[x] = min(ans[x], i);
	}
	fdi(n+1, 1){
		ans[i-1] = min(ans[i], ans[i-1]);
		if(ans[i] > m) ans[i] = -1;
	}
}

int main(){
#ifdef _DEBUG
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
#endif

	int t;
	scanf("%d",&t);
	while(t--){
		scanf("%d %d\n",&m,&n);
		fi(0, n) scanf("%c ",&c[i]);
		fi(0, n) scanf("%d",&s[i]);
		fi(0, n) scanf("%d",&d[i]);
		solve();
		fi(1, n+1) printf("%d ",ans[i]);
		printf("\n");
	}

	return 0;
}