#include<bits/stdc++.h>
#define OO 1e9
using namespace std;

#define ll long long
const int SIZE=5*100000+100;
int nodesgive[2][SIZE];
int nodestake[2][SIZE];
ll dp[2][SIZE+100][2][2];
int n,m;


void solvebu(){

    for(int i=0; i<SIZE; i++){
        for(int j=0; j<2; j++){
         for(int k=0; k<2; k++){


        if(i!=0){
        dp[(m+1)%2][i][j][k]=OO;
        }
        dp[i%2][0][j][k]=0;
         }

        }
    }





    for(int idx=m; idx>=1; idx--){
        int p=idx%2;
        for(int rem=1; rem<=n; rem++){
            for(int dc=0; dc<2; dc++){
                for(int e=0; e<2; e++){
    ll &ret=dp[p][rem][dc][e];
    ret=1+dp[!p][rem][dc][e];
    if(e==0){
        if(nodesgive[0][idx]!=0){
            ret=min(ret,1+dp[!p][rem][0][1]);
        }
        else if(nodesgive[1][idx]!=0){
            ret=min(ret,1+dp[!p][rem][1][1]);
        }

    }
    else{
        if(nodestake[0][idx]!=0 && dc==0){
                    if(nodestake[0][idx]>=rem) ret=0;
            ret=min(ret,dp[p][max(rem-nodestake[0][idx],0)][0][0]);
            ret=min(ret,1+dp[!p][max(rem-nodestake[0][idx],0)][0][1]);
        }
        else if(nodestake[1][idx]!=0 && dc==1){
                if(nodestake[1][idx]>=rem) ret=0;
                       ret=min(ret,dp[p][max(rem-nodestake[1][idx],0)][1][0]);
            ret=min(ret,1+dp[!p][max(rem-nodestake[1][idx],0)][1][1]);
        }
    }

                }
            }

        }


    }


}
ll solve(int idx, int rem, bool dc, bool e){


    if(idx==m+1 && rem!=0) return OO;

    if(rem==0) return 0;
        if(dp[idx][rem][dc][e]!=-1)return dp[idx][rem][dc][e];
    ll ret=1+solve(idx+1,rem,dc,e);

    if(e==0){
        if(nodesgive[0][idx]!=0){
            ret=min(ret,1+solve(idx+1,rem,0,1));
        }
        else if(nodesgive[1][idx]!=0){
            ret=min(ret,1+solve(idx+1,rem,1,1));
        }

    }
    else{
        if(nodestake[0][idx]!=0 && dc==0){
                if(nodestake[0][idx]>=rem) return 0;
            ret=min(ret,solve(idx,max(rem-nodestake[0][idx],0),0,0));
            ret=min(ret,1+solve(idx+1,max(rem-nodestake[0][idx],0),0,1));
        }
        else if(nodestake[1][idx]!=0 && dc==1){
            if(nodestake[1][idx]>=rem) return 0;
            ret=min(ret,solve(idx,max(rem-nodestake[1][idx],0),1,0));
            ret=min(ret,1+solve(idx+1,max(rem-nodestake[1][idx],0),1,1));
        }
    }
    return dp[idx][rem][dc][e]=ret;



}

struct edge{

    int from,to,type;
};

int main()
{

int t;
cin>>t;
while(t--){
        memset(nodesgive,0,sizeof nodesgive);
memset(nodestake,0,sizeof nodestake);
    cin>>m>>n;
    vector<edge> vec(n);
    
    for(int i=0; i<n; i++){
        char c;
        cin>>c;
        if(c=='D' || c=='M')
        vec[i].type=1;
        else{
            vec[i].type=0;
        }
    }
    for(int i=0; i<n; i++){
        cin>>vec[i].from;
    }
    for(int i=0; i<n; i++){
        cin>>vec[i].to;

    }


    for(int i=0; i<vec.size(); i++){
            if(vec[i].from>vec[i].to )continue;
        nodesgive[vec[i].type][vec[i].from]++;
        nodestake[vec[i].type][vec[i].to]++;


    }

    solvebu();
    //cout<<"J";

    for(int i=1; i<=n; i++){
       ll ret=dp[1][i][0][0];
       if(ret>=OO) cout<<"-1 ";
       else cout<<ret+1<<" ";
    }
    cout<<endl;
}
}