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

const int N = 50001;
int n, m, src[N], dest[N];
vector<int> cands[N];
char kind[N];
// for computation
int d[N], x[N][2];
// d[i] stands for best value from 1..i
// x[i][g] stands for number of g-elements i..CURRENT
// d[CURRENT] = max(d[i] + x[i][g]) for all i from 1..CURRENT-1 and all g from 1..2

int belongsTo(char c, int i) {
    if (c == 'E') {
        return i == 0;
    }
    if (c == 'D') {
        return i == 1;
    }
    if (c == 'C') {
        return i == 0;
    }
    return i == 1;
}


struct LazySegmentTree {
    struct Segment {
        int add = 0;
        int maks = 0;
        Segment() {
            add = maks = 0;
        }
    };
    
    vector<Segment> tree;
    
    LazySegmentTree(int n = 0) {
        tree.assign(n * 4 + 1, Segment());
    }

    void pushdown(int x, int i, int j) {
        if (tree[x].add == 0) return;
        if (i != j) {
            tree[x + x].add += tree[x].add;
            tree[x + x + 1].add += tree[x].add;
            tree[x].maks = max(
                tree[x+x].maks + tree[x+x].add, tree[x+x+1].maks + tree[x+x+1].add);
        } else {
            tree[x].maks += tree[x].add;
        }
        // must empty
        tree[x].add = 0;
    }

    void add(int x, int i, int j, int l, int r, int val) {    
        if (i >= l && j <= r) {
            tree[x].add += val;
            return;
        }
        if (i > r || j < l) {
            return;
        }
        pushdown(x, i, j);
        int m = (i + j) / 2;
        add(x + x,     i,     m, l, r, val);
        add(x + x + 1, m + 1, j, l, r, val);
        tree[x].maks = max(tree[x+x].maks+tree[x+x].add,tree[x+x+1].maks+tree[x+x+1].add);
    }

    int getMax(int x, int i, int j, int l, int r) {
        if (i >= l && j <= r) {
            return tree[x].maks + tree[x].add;
        }
        if (i > r || j < l) {
            return 0;
        }
        int m = (i + j) / 2;
        pushdown(x, i, j);
        int u = getMax(x + x,     i,     m, l, r);
        int v = getMax(x + x + 1, m + 1, j, l, r);
        return max(u, v);
    }
};

int main() {
    int T; cin >> T;
    while (T--) {
        cin >> m >> n;
        
        LazySegmentTree tree[2];
        tree[0] = LazySegmentTree(m);
        tree[1] = LazySegmentTree(m);
            
        for (int i = 0; i <= m; ++i) {
            cands[i].clear();
            d[i] = x[i][0] = x[i][1] = 0;
        }
        for (int i = 1; i <= n; ++i) {
            cin >> kind[i];
        }
        for (int i = 1; i <= n; ++i) {
            cin >> src[i];
        }
        for (int i = 1; i <= n; ++i) {
            cin >> dest[i];
            if (src[i] < dest[i]) {
                cands[dest[i]].push_back(i);
            }
        }

        for (int zoo = 1; zoo <= m; ++zoo) {
            d[zoo] = d[zoo - 1];
            for (int g = 0; g < 2; ++g) {
                for (int i: cands[zoo]) {
                    if (!belongsTo(kind[i], g)) {
                        continue;
                    }
                    tree[g].add(1, 1, m, 1, src[i], 1);
                }
                d[zoo] = max(d[zoo], tree[g].getMax(1, 1, m, 1, zoo - 1));
            }
        
            tree[0].add(1, 1, m, zoo, zoo, d[zoo]);
            tree[1].add(1, 1, m, zoo, zoo, d[zoo]);
        }

        int pos = 1;
        for (int i = 1; i <= n; ++i) {
            while (pos <= m && d[pos] < i) {
                pos += 1;
            }
            if (pos <= m && d[pos] >= i) {
                cout << pos << " ";
            } else {
                cout << "-1 ";
            }
        }
        cout << "\n";
    }
}