#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
vector< int > dog_mice[50001];
vector< int > cat_elephant[50001];
int C[50001];
int D[50001];
char ty[50001];
int from[50001];
int Dp[50001];
int ans[50001];
int segment_dog[200001];
int segment_cat[200001];
int lazy_dog[200001];
int lazy_cat[200001];
int query_cat(int node, int l, int r, int s, int e){
    if(s > r || l > e || s > e) return 0;
    if(lazy_cat[node] != 0){
        segment_cat[node] += lazy_cat[node];
        if(l != r){
            lazy_cat[2 * node] += lazy_cat[node];
            lazy_cat[2 * node + 1] += lazy_cat[node];
        }
        lazy_cat[node] = 0;
    }
    if(l >= s && r <= e) return  segment_cat[node];
    return max(query_cat(2 * node, l, (l + r)/2, s, e) , query_cat(2 * node + 1, (l + r)/2 + 1, r, s, e));
    
}

int query_dog(int node, int l, int r, int s, int e){
    if(s > r || l > e || s > e) return 0;
    if(lazy_dog[node] != 0){
        segment_dog[node] += lazy_dog[node];
        if(l != r){
            lazy_dog[2 * node] += lazy_dog[node];
            lazy_dog[2 * node + 1] += lazy_dog[node];
        }
        lazy_dog[node] = 0;
    }
    if(l >= s && r <= e) return  segment_dog[node];
    return max(query_dog(2 * node, l, (l + r)/2, s, e) , query_dog(2 * node + 1, (l + r)/2 + 1, r, s, e));
    
}
void update_cat(int node, int l, int r, int s, int e, int value){
    if(lazy_cat[node] != 0){
        segment_cat[node] += lazy_cat[node];
        if(l != r){
            lazy_cat[2 * node] += lazy_cat[node];
            lazy_cat[2 * node + 1] += lazy_cat[node];
        }
        lazy_cat[node] = 0;
    }
    if(s > r || l > e) return;
    if(l >= s && r <= e){
        segment_cat[node] += value;
        if( l != r){
            lazy_cat[node * 2] += value;
            lazy_cat[2 *  node + 1] += value;
        }
        return;
    }
    update_cat(2 * node, l, (l + r)/2 , s, e, value);
    update_cat(2 * node + 1, (l + r)/2 + 1, r, s, e , value);
    segment_cat[node] = max(segment_cat[2 * node], segment_cat[2 * node + 1]);
}

void update_dog(int node, int l, int r, int s, int e, int value){
    if(lazy_dog[node] != 0){
        segment_dog[node] += lazy_dog[node];
        if(l != r){
            lazy_dog[2 * node] += lazy_dog[node];
            lazy_dog[2 * node + 1] += lazy_dog[node];
        }
        lazy_dog[node] = 0;
    }
    if(s > r || l > e) return;
    if(l >= s && r <= e){
        segment_dog[node] += value;
        if( l != r){
            lazy_dog[node * 2] += value;
            lazy_dog[2 *  node + 1] += value;
        }
        return;
    }
    update_dog(2 * node, l, (l + r)/2 , s, e, value);
    update_dog(2 * node + 1, (l + r)/2 + 1, r, s, e , value);
    segment_dog[node] = max(segment_dog[2 * node], segment_dog[2 * node + 1]);
}
int main(){
    cin.sync_with_stdio(false);
    int t;
    cin >> t;
    while(t--){
        int m, n;
        cin >> m >> n;
        for(int i = 1 ; i <= m ; ++i) dog_mice[i].clear(), cat_elephant[i].clear(), Dp[i] = 0, C[i] = 0, D[i] = 0;
        for(int i = 1 ; i <= 4 * m ; ++i)  segment_dog[i] = lazy_dog[i] = segment_cat[i] = lazy_cat[i] = 0;
        for(int i = 1 ; i <= n ; ++i) ans[i] = -1;
        for(int i = 1 ; i <= n ; ++i) cin >> ty[i];
        for(int i = 1 ; i <= n ; ++i) cin >> from[i];
        for(int i = 1 ; i <= n ; ++i){
            int to;
            cin >> to;
            if(from[i] < to){
                if(ty[i] == 'D' || ty[i] == 'M')
                    dog_mice[to].push_back(from[i]),  ++D[to]; else
                        cat_elephant[to].push_back(from[i]), ++C[to] ;
            }
        }
       
        for(int i = 1 ; i <= m ; ++i){
            D[i] += D[i - 1];
            C[i] += C[i - 1];
        }
      
        for(int i = 1 ; i <= m ; ++i){
            Dp[i] = Dp[i - 1];
            
            for(int j = 0 ; j < dog_mice[i].size() ; ++j){
                int idx = dog_mice[i][j] + 1;
                if(idx < i)
                    update_dog(1, 1, m, idx , i - 1, -1);
            }
            for(int j = 0 ; j < cat_elephant[i].size() ; ++j){
                int idx = cat_elephant[i][j] + 1;
                if(idx < i) update_cat(1, 1, m, idx, i - 1, -1);
            }
            
            Dp[i] = max(Dp[i], query_dog(1, 1, m, 1, i - 1) + D[i]);
            Dp[i] = max(Dp[i], query_cat(1, 1, m, 1, i - 1) + C[i]);
            update_dog(1, 1, m, i, i, Dp[i] - D[i]);
            update_cat(1, 1, m, i, i, Dp[i] - C[i]);
            
        }
        
        int st = 0;
        for(int i = 1 ; i <= m ; ++i){
            while(st < Dp[i]){
                ++st;
                ans[st] = i;
            }
        }
        for(int i = 1 ; i <= n ; ++i )
            cout << ans[i] << " ";
        cout << endl;
    }
}