#include <bits/stdc++.h>

using namespace std;

const int N = 1e3 + 10;
const int INF = 1e9;

int n, m;

int r[80], c[80];

char s[80][80];

int S = 0, T = 1e3;

int tot;

map <string, int> mp;

map <string, int> vis;

struct graph
{
    int cnt, head[N];
    struct edge
    {
        int to, nxt, flow;
        edge(int v = 0, int x = 0, int f = 0) :
            to(v), nxt(x), flow(f) {}
    }e[N * N];
    void add(int u, int v, int f)
    {
        e[++cnt] = edge(v, head[u], f); head[u] = cnt;
        e[++cnt] = edge(u, head[v], 0); head[v] = cnt;
    }
    void init()
    {
        cnt = 1;
        memset(head, 0, sizeof(head));
    }
}G;

void init()
{
    G.init(); mp.clear(); tot = 0; vis.clear();
}

bool check1(string s)
{
    int len = s.size();
    for(int i = 0; i <= (len - 1) / 2; i++)
        if(s[i] != s[len - i - 1])return 0;
    return 1;
}

bool check2(string s)
{
    string a = s, b = s;
    reverse(b.begin(), b.end());
    return a < b;
}

void push(string s)
{
    string a = s, b = s;
    reverse(b.begin(), b.end());
    if(a > b)swap(a, b);
    mp[a] = ++tot, mp[b] = ++tot;
    G.add(mp[a], mp[b], 2);
}

void insert(string s, int f)
{
    if(!mp.count(s))push(s);
    if(f)G.add(S, mp[s], INF);
    else G.add(mp[s], T, INF);
}

void add(string s, int x)
{
    string a = s, b = s;
    reverse(b.begin(), b.end());
    if(a > b)swap(a, b);
    G.add(mp[b], x, INF);
    G.add(x, mp[a], INF);
}

int depth[N];

bool bfs()
{
    memset(depth, 0, sizeof(depth));
    depth[S] = 1; queue <int> q; q.push(S);
    while(!q.empty())
    {
        int x = q.front(); q.pop();
        for(int i = G.head[x]; i; i = G.e[i].nxt)
        {
            int v = G.e[i].to, f = G.e[i].flow;
            if(f && !depth[v])
            {
                depth[v] = depth[x] + 1;
                q.push(v);
            }
        }
    }
    return depth[T];
}

int dfs(int x, int in)
{
    if(x == T)return in;
    int out = 0;
    for(int i = G.head[x]; i; i = G.e[i].nxt)
    {
        if(in <= 0)break;
        int v = G.e[i].to, f = G.e[i].flow;
        if(f && depth[v] == depth[x] + 1)
        {
            int res = dfs(v, min(in, f));
            G.e[i].flow -= res;
            G.e[i ^ 1].flow += res;
            in -= res; out += res;
        }
    }
    if(!out)depth[x] = 0;
    return out;
}

int dinic()
{
    int maxflow = 0;
    while(bfs())maxflow += dfs(S, INF);
    return maxflow;
}

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++)
            scanf("%d", &r[i]);
        for(int i = 1; i <= m; i++)
            scanf("%d", &c[i]);
        for(int i = 1; i <= n; i++)
            scanf("%s", s[i] + 1);
        int ans = 0; tot = n + m;
        for(int i = 1; i <= n; i++)
        {
            string str = ""; s[i][m + 1] = '_';
            for(int j = 1; j <= m + 1; j++)
            {
                if(s[i][j] == '_')
                {
                    if(str == "")continue;
                    if(check1(str) && !vis[str])
                        ans++, vis[str] = 1;
                    else
                    {
                        if(r[i])
                            insert(str, check2(str));
                        else add(str, i);
                    }
                    str = "";
                }
                else str += s[i][j];
            }
        }
        for(int j = 1; j <= m; j++)
        {
            string str = ""; s[n + 1][j] = '_';
            for(int i = 1; i <= n + 1; i++)
            {
                if(s[i][j] == '_')
                {
                    if(str == "")continue;
                    if(check1(str) && !vis[str])
                        ans++, vis[str] = 1;
                    else
                    {
                        if(c[j])
                            insert(str, check2(str));
                        else add(str, j + n);
                    }
                    str = "";
                }
                else str += s[i][j];
            }
        }
        printf("%d\n", ans + dinic());
    }
    return 0;
}