import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    

    static class Node{
        int start;
        int dest;
        Character c;
        public Node(int start, int dest, char c){
            this.start = start;
            this.dest = dest;
            this.c = c;
        }
    }
    
    static int[] minimumZooNumbers(int m, int n, char[] t, int[] s, int[] d) {
        int e_cnt = 0, d_cnt = 0;
        for(int i=0;i<n;i++){
            if(t[i] == 'E' || t[i] == 'C') e_cnt++;
            else d_cnt++;
        }
        Node[] e_sd = new Node[e_cnt];
        Node[] d_sd = new Node[d_cnt];
        ArrayList<int[]>[] drop = new ArrayList[m+1];
        for(int i=0;i<n;i++){
            if(t[i] == 'E' || t[i] == 'C'){
                e_sd[(e_cnt--) - 1] = new Node(s[i], d[i], 'E');
            }else{
                d_sd[(d_cnt--) - 1] = new Node(s[i], d[i], 'D');
            }
            if(drop[d[i]] == null){
                drop[d[i]] = new ArrayList();
            }
            drop[d[i]].add(new int[]{t[i] == 'E' || t[i] == 'C' ? 0 : 1, s[i]});
        }
        
        Arrays.sort(e_sd, (a,b) -> a.start - b.start);
        Arrays.sort(d_sd, (a,b) -> a.start - b.start); 
/*        for(int i=0;i<e_sd.length;i++){
            System.out.println(e_sd[i].start + "  " + e_sd[i].dest + "  " + e_sd[i].c);
        }
        for(int i=0;i<d_sd.length;i++){
            System.out.println(d_sd[i].start + "  " + d_sd[i].dest + "  " + d_sd[i].c);
        } */
        
        int[] dp = new int[m+1];
        dp[1] = 0;
        for(int i=2;i<=m;i++){
            ArrayList<int[]> dropList = drop[i];
//            System.out.println(dropList == null ? "null" : dropList.size());
            dp[i] = dp[i-1];
            if(dropList == null) continue;
            for(int x = 0; x < dropList.size(); x++){
                int[] info = dropList.get(x);
                int left = info[1];
                int right = i;
 //               System.out.println(left + "  " + right + "  " + info[0]);
                Node[] animal_arr = info[0] == 0 ? e_sd : d_sd;
                int lower = lowB(animal_arr, left);
                int higher = upB(animal_arr, right);
 //              System.out.println(lower + "  " + higher + "----" + left + "  " + right);
                int count = 0;
                for(int j=lower;j <= higher && j<animal_arr.length;j++){
                    if(animal_arr[j].dest <= right){
                        count++;
                    }
                }
                dp[i] = Math.max(dp[i], dp[left] + count);
            }
        }
        int[] ans = new int[n];
        Arrays.fill(ans, -1);
        for(int i=1;i<=m;i++){
            if(dp[i] == 0) continue;
            ans[dp[i]-1] = ans[dp[i]-1] == -1 ? i : Math.min(ans[dp[i]-1], i);
        }
        for(int i=ans.length-2;i>=0;i--){
            if(ans[i] == -1){
                ans[i] = ans[i+1];
            }
        }
        return ans;
    }
    
    static int lowB(Node[] arr, int val){
        int mid;
        int l=0,r=arr.length-1;
        while(l <= r){
//            System.out.println(l + "  " + r + " lowB");
            mid = l + (r-l)/2;
            if(arr[mid].start == val){
                if(l == mid) return mid;
                r = mid;
            }else if(arr[mid].start > val){
                r = mid-1;
            }else{
                l = mid+1;
            }
        }
        return l;
    }

    static int upB(Node[] arr, int val){
        int mid;
        int l=0,r=arr.length-1;
        while(l <= r){
//            System.out.println(l + "  " + r + " upB");
            mid = l + (r-l)/2;
            if(arr[mid].start == val){
                if(l == mid) return mid;
                l = mid;
            }else if(arr[mid].start > val){
                r = mid-1;
            }else{
                l = mid+1;
            }
        }
        return r;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int cases = in.nextInt();
        for(int a0 = 0; a0 < cases; a0++){
            int m = in.nextInt();
            int n = in.nextInt();
            char[] t = new char[n];
            for(int t_i = 0; t_i < n; t_i++){
                t[t_i] = in.next().charAt(0);
            }
            int[] s = new int[n];
            for(int s_i = 0; s_i < n; s_i++){
                s[s_i] = in.nextInt();
            }
            int[] d = new int[n];
            for(int d_i = 0; d_i < n; d_i++){
                d[d_i] = in.nextInt();
            }
            int[] result = minimumZooNumbers(m, n, t, s, d);
            for (int i = 0; i < result.length; i++) {
                System.out.print(result[i] + (i != result.length - 1 ? " " : ""));
            }
            System.out.println("");


        }
        in.close();
    }
}