#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <set>
#include <map>
#include <cassert>
#include <ctime> 
#include <cmath>
#include <string>
#include <cstring>
#include <queue>
using namespace std;

#define f first
#define s second
#define mp make_pair
#define pb push_back
#define pii pair<int, int>
#define vi vector<int>
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)((v).size())
#define forit(it,v) for (__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define f0(a) memset(a, 0, sizeof(a))
#define ll long long
const int maxn = (int)1e5;

struct Node {
	int value = 0, push = 0;
};

struct Tree {
	Node t[maxn * 8];

	void build() {
		for (int i = 0; i < maxn * 8; ++i)
			t[i] = Node();
	}
	
	void push(int v, int tl, int tr) {
		t[v].value += t[v].push;
		if (tl != tr) {
			t[v + v].push += t[v].push;
			t[v + v + 1].push += t[v].push;
		}
		t[v].push = 0;
	}

	void update(int v) {
		t[v].value = max(t[v + v].value, t[v + v + 1].value);
	}

	void increase(int v, int tl, int tr, int till) {
		push(v, tl, tr);
		if (tl >= till) return;
		if (tr < till) {
			t[v].push++;
			push(v, tl, tr);
			return;
		}
		int mid = (tl + tr) / 2;
		increase(v + v, tl, mid, till);
		increase(v + v + 1, mid + 1, tr, till);
		update(v);
	}

	void increase(int n) {
		increase(1, 0, maxn - 1, n);
	}

	void setValue(int v, int tl, int tr, int at, int value) {
		push(v, tl, tr);

		if (!(tl <= at && at <= tr)) return;

		if (tl == tr) {
			t[v].value = value;
			return;
		}

		int mid = (tl + tr) / 2;
		setValue(v + v, tl, mid, at, value);
		setValue(v + v + 1, mid + 1, tr, at, value);
		update(v);
	}
	
	void setValue(int at, int value) {
		setValue(1, 0, maxn - 1, at, value);
	}

	int findMax(int v, int tl, int tr, int till) {
		push(v, tl, tr);
		if (tl >= till) return 0;
		if (tr < till) return t[v].value;
		int mid = (tl + tr) / 2;
		return max(findMax(v + v, tl, mid, till), 
							 findMax(v + v + 1, mid + 1, tr, till));
	}

	int findMax(int n) {
		return findMax(1, 0, maxn - 1, n);	
	}
};

struct Intervals {
	vector<int> zoos;
	vector<int> values;
	Tree tree;
	void reset() {
		zoos.clear();
		values.clear();
		tree.build();

		zoos.push_back(0);
		values.push_back(0);
	}

	void add(int ri, int value) {
		zoos.push_back(ri);
		tree.setValue(sz(zoos) - 1, value);
	}

	int findMax(int before) {
		int index = findIndex(before);
		return tree.findMax(index);
	}

	void increase(int before) {
		int index = findIndex(before);
		tree.increase(index);
	}

	int findIndex(int before) {
		int p = upper_bound(all(zoos), before) - zoos.begin();
		return p;
	}
};

struct Animal {
	int le, ri, type;
};
int n, m;
int type[maxn];
int src[2][maxn];

Intervals intervals[2];
int answer[maxn];

void solve() {
	scanf("%d%d\n", &m, &n);

	for (int i = 1; i <= m; ++i) answer[i] = 0;

	for (int i = 0; i < n; ++i) {
		char c;
		scanf("%c ", &c);
		type[i] = (c == 'D' || c == 'M');
	}

	for (int j = 0; j < 2; ++j) {
		for (int i = 0; i < n; ++i) {
			scanf("%d", &src[j][i]);
		}
	}
	vector<Animal> animals;
	for (int i = 0; i < n; ++i) if (src[0][i] < src[1][i]) {
		animals.push_back(Animal{src[0][i], src[1][i], type[i]});
	}

	sort(all(animals), [](const Animal &a, const Animal &b) {
		return a.ri < b.ri;
	});
	
	intervals[0].reset();
	intervals[1].reset();
	
	for (auto animal: animals) {
		int t = animal.type;
		intervals[1 - t].increase(animal.le);
		int maxi = intervals[1 - t].findMax(animal.le);
		intervals[t].add(animal.ri, maxi);
		answer[animal.ri] = max(answer[animal.ri], maxi);
	}
	for (int i = 1; i <= m; ++i) {
		answer[i] = max(answer[i - 1], answer[i]);
	}
	int cur = 1;
	for (int i = 1; i <= n; ++i) {
		while (cur <= m && answer[cur] < i) cur++;
		if (cur > m) printf("-1 "); else printf("%d ", cur);
	}
	cout << endl;
	
}

int main() {
	int tests;
	scanf("%d", &tests);
	for (int t = 1; t <= tests; ++t) solve();
	return 0;
}