#include<bits/stdc++.h>
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define ri(x) scanf("%d",&(x))
#define ri2(x,y) scanf("%d %d",&(x),&(y))
#define ri3(x,y,z) scanf("%d %d %d",&(x),&(y),&(z))
#define rll(x) scanf("%lld",&(x))
#define rll2(x,y) scanf("%lld %lld",&(x),&(y))
#define rll3(x,y,z) scanf("%lld %lld %lld",&(x),&(y),&(z))
#define gc(x) ((x) = getchar())
using namespace::std;

const long double PI = acos(-1);
const long long MOD = 1000000000 +7;

typedef long long ll;
typedef pair<ll,ll> pll;
typedef pair<ll,pll> tll;
typedef pair<int,int> ii;
typedef pair<int,ii> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<ll> vll;
typedef vector<pll> vpll;
typedef vector<tll> vtll;
typedef vector<string> vs;
typedef set<int> si;
typedef set<ii> sii;
typedef set<iii> siii;

ll gcd(ll a, ll b){ return b==0?a:gcd(b,a%b);}

ll add(ll a, ll b, ll m = MOD){
	if(a >= m) a %= m;
	if(b >= m) b %= m;
	if(a < 0) a += m;
	if(b < 0) b += m;
	ll res = a+b;
	if(res >= m or res <= -m) res %= m;
	if(res < 0) res += m;
	return res;
}

ll mul(ll a, ll b, ll m = MOD){
	if(a >= m) a %= m;
	if(b >= m) b %= m;
	if(a < 0) a += m;
	if(b < 0) b += m;
	ll res = a*b;
	if(res >= m or res <= -m) res %= m;
	if(res < 0) res += m;
	return res;
}

ll pow_mod(ll a, ll b, ll m = MOD){
	ll res = 1LL;
	a = a%m;
	while(b){
		if(b&1) res = mul(res,a,m);
		b >>= 1;
		a = mul(a,a,m);
	}
	return res;
}

ll fastexp(ll a, ll b){
	ll res = 1LL;
	while(b){
		if(b&1) res = res*a;
		b >>= 1;
		a *= a;
	}
	return res;
}

int gcdExtendido(int a, int b, int *x, int *y){
	if(a == 0){
		*x = 0;
		*y = 1;
		return b;
	}
	int x1, y1;
	int gcd = gcdExtendido(b%a,a,&x1,&y1);
	
	*x = y1-(b/a)*x1;
	*y = x1;
	return gcd;
}

int modInverso(int a, int m){
	int x, y;
	int g = gcdExtendido(a,m,&x,&y);
	if(g!=1) return -1;
	else return (x%m + m)%m;
}

/****************************************
*************P*L*A*N*T*I*L*L*A************
*****************************************/

const int N = 4000+5;
const int E = 26;

int n;
int l;
char a[N];
char v[N];
// Trie memory
int h[N];
int edges;
int ch[N];
int to[N];
int nodes;
int nxt[N];
bool pat[N];
int last[N];
int closest[N];
// DP memory
int memo[N][N][2];

void addNode(){
	pat[nodes] = false;
	last[nodes] = -1;
	nodes += 1;
}

void addEdge(int u, int v, int c){
	ch[edges] = c;
	to[edges] = v;
	nxt[edges] = last[u];
	last[u] = edges;
	edges += 1;
}

int find(int u, int label){
	for(int e = last[u]; e != -1; e = nxt[e]){
		if(ch[e] == label) return e;
	}
	return -1;
}

void insert(int npat){
	int pos = 0;
	for(int i = 0; v[i] ; i++){
		int nxt = v[i] - 'A';
		if(find(pos, nxt) == -1){
			h[nodes] = h[pos] + 1;
			addEdge(pos, nodes, nxt);
			addNode();
		}
		pos = to[find(pos, nxt)];
	}
	pat[pos] = true;
}

void DFS(int u){
	closest[u] = pat[u]? 0 : 1e9;
	for(int e = last[u]; e != -1; e = nxt[e]){
		int v = to[e];
		DFS(v);
		if(closest[v] + 1 < closest[u]){
			closest[u] = closest[v] + 1;
		}
	}
}

int solve(){
	DFS(0);
	n = strlen(a);
	vector<int> p(nodes);
	iota(all(p), 0);
	sort(all(p), [&] (int i, int j){
		return h[i] > h[j];
	});
	for(int stay = 0; stay < 2; stay++){
		for(int state = 0; state < nodes; state++){
			memo[n][state][stay] = state? closest[state] : 0;
		}
	}
	for(int pos = n - 1; pos >= 0; pos--){ // Posicion en a
		for(int stay = 0; stay < 2; stay++){ // Si puedo regresar a la raiz o no
			for(int state : p){ // Estado del trie
				int ans = 1e9;
				for(int e = last[state], cand; e != -1; e = nxt[e]){
					// Reemplazar a[pos]
					cand = (ch[e] + 'A' != a[pos]) + memo[pos + 1][to[e]][1];
					if(ans > cand) ans = cand;
					// Borrar la letra ch[e] y avanzar al siguiente estado de todas formas
					cand = 1 + memo[pos][to[e]][0];
					if(ans > cand) ans = cand;
				}
				// Reiniciar el string 
				if(stay) ans = min(ans, closest[state] + memo[pos][0][0]);
				// Borrar a[pos]
				ans = min(ans, 1 + memo[pos + 1][state][1]);
				memo[pos][state][stay] = ans;
			}
		}
	}
	return memo[0][0][1];
}

int main(){
	int t;
	ri(t);
	while(t--){
		ri(l);
		nodes = edges = 0;
		addNode();
		for(int i = 1; i <= l; i++){
			scanf("%s", v);
			insert(i);
		}
		scanf("%s", a);
		printf("%d\n", solve());
	}
	return 0;
}