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

char type[50004];
int S[50004], D[50004];
int dp[50004][2], pre[50004][2], tree[200005][2], lazy[200005][2];

vector<int> X[50004][2];

int getType(char x)
{
    if(x == 'E' || x == 'C')
        return 0;
    
    return 1;
}

void prop(int root, int flag, int left, int right)
{
    tree[root][flag] += lazy[root][flag];
    
    if(left != right)
    {
        lazy[root*2][flag] += lazy[root][flag];
        lazy[root*2+1][flag] += lazy[root][flag];
    }
    
    lazy[root][flag] = 0;
}
    
void update(int left, int right, int L, int R, int val, int flag, int root)
{
    if(lazy[root][flag])
        prop(root, flag, left, right);
    
    if(left > R || right < L)
        return;
    
    if(left >= L && right <= R)
    {
        tree[root][flag]+= val;
        
        if(left != right)
            lazy[root*2][flag]+= val, lazy[root*2+1][flag]+= val;
        
        return;
    }
    
    int mid = (left + right)/2;
    
    update(left, mid, L, R, val, flag, root*2);
    update(mid+1, right, L, R, val, flag, root*2+1);
    
    tree[root][flag] = max(tree[root*2][flag], tree[root*2+1][flag]);
}

int getMax(int left, int right, int L, int R, int flag, int root)
{
    if(lazy[root][flag])
        prop(root, flag, left, right);
    
    if(left > R || right < L)
        return 0;
    
    if(left >= L && right <= R)
        return tree[root][flag];
    
    int mid = (left + right)/2;
    
    return max(getMax(left, mid, L, R, flag, root*2), getMax(mid+1, right, L, R, flag, root*2+1));
}

int main() {
    
    int T;
    scanf("%d", &T);
    
    while(T--)
    {
        int M, N;
        scanf("%d %d", &M, &N);
        
        for(int i=1; i<=M; i++)
            X[i][0].clear(), X[i][1].clear();
        
        for(int i=1; i<=N; i++)
            scanf(" %c", &type[i]);
        for(int i=1; i<=N; i++)
            scanf("%d", &S[i]);
        for(int i=1; i<=N; i++)
            scanf("%d", &D[i]);
        
        for(int i=1; i<=N; i++)
            X[ D[i] ][getType(type[i])].push_back(S[i]);
        
        memset(dp, 0, sizeof(dp));
        memset(tree, 0, sizeof(tree));
        memset(lazy, 0, sizeof(lazy));
        
        for(int i=1; i<=M; i++)
        {
            for(int j=0; j<X[i][0].size(); j++)
                update(1, M, 1, X[i][0][j], 1, 1, 1);
            for(int j=0; j<X[i][1].size(); j++)
                update(1, M, 1, X[i][1][j], 1, 0, 1);
            
            for(int j=0; j<X[i][0].size(); j++)
                dp[i][0] = max(dp[i][0], getMax(1, M, 1, X[i][0][j], 1, 1));
            for(int j=0; j<X[i][1].size(); j++)
                dp[i][1] = max(dp[i][1], getMax(1, M, 1, X[i][1][j], 0, 1));
            
            pre[i][0] = pre[i-1][0], pre[i][1] = pre[i-1][1];
            
            dp[i][0] = max(dp[i][0], pre[i][0] + (int)X[i][0].size());
            dp[i][1] = max(dp[i][1], pre[i][1] + (int)X[i][1].size());
            
            pre[i][0] = max(pre[i][0], dp[i][0]);
            pre[i][1] = max(pre[i][1], dp[i][1]);
            
            update(1, M, i, i, dp[i][0], 0, 1);
            update(1, M, i, i, dp[i][1], 1, 1);
        }
        
        int ptr = 1;
        
        for(int i=1; i<=N; i++)
        {
            while(ptr <= M && max(dp[ptr][0], dp[ptr][1]) < i)
                ptr++;
            
            if(ptr > M)
                printf("-1 ");
            else
                printf("%d ", ptr);
        }
        
        printf("\n");
    }
    
    return 0;
}