def solve():
    n = int(input())
    s = input()
    cnt = set()
    for i in range(1, n):
        cnt.add(s[i - 1] + s[i])
    print(len(cnt))


t = int(input())
for _ in range(t):
    solve()

#include<bits/stdc++.h>
using namespace std;
void  solve(){
    int n, k;
    cin >> n >> k;
    vector<pair<int, int>>a(n);
    vector<int>b(n), ans(n);
    for(int i = 0; i < n; i++){
        cin >> a[i].first;
        a[i].second = i;
    }
    for(auto &i : b) cin >> i;
    sort(b.begin(), b.end());
    sort(a.begin(), a.end());

    for(int i = 0; i < n; i++){
        ans[a[i].second] = b[i];
    }
    for(auto &i : ans) cout << i << ' ';
    cout << endl;
}
int main(){
    int t;
    cin >> t;
    while(t--) solve();
}

def solve():
    n = int(input())
    a = [int(x) for x in input().split()]
    a.sort()
    if a[0] % 2 == 1:
        print("YES")
        return
    for i in range(n):
        if a[i] % 2 == 1:
            print("NO")
            return
    print("YES")


t = int(input())
for _ in range(t):
    solve()

#include <bits/stdc++.h>

using namespace std;

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define sz(v) (int)v.size()
#define all(v) v.begin(),v.end()
#define eb emplace_back



void solve() {
    int n; cin >> n;
    vector<int> p(n);
    for (auto &e : p) cin >> e;

    int r = 0;
    for (int i = 0; i < n; ++i) {
        if (p[min(n-1, r+1)] <= p[min(n-1, i+1)]) {
            r = i;
        }
    }
    vector<int> ans;
    for (int i = r + 1; i < n; ++i) ans.eb(p[i]);
    ans.eb(p[r]);
    for (int i = r-1; i >= 0; --i) {
        if (p[i] > p[0]) {
            ans.eb(p[i]);
        } else {
            for (int j = 0; j <= i; ++j) {
                ans.eb(p[j]);
            }
            break;
        }
    }
    for (auto e : ans) cout << e << ' ';
    cout << endl;
}

int main() {
    int t;
    cin >> t;

    forn(tt, t) {
        solve();
    }
}

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>

using namespace std;

typedef long long ll;

void solve() {
    int n;
    cin >> n;
    vector<int> a(n);
    vector<set<int>> g(n);
    vector<set<int>> neighbours(n);
    vector<int> d(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        a[i]--;
        g[i].insert(a[i]);
        g[a[i]].insert(i);
    }
    for (int i = 0; i < n; ++i) {
        d[i] = g[i].size();
    }
    int bamboos = 0, cycles = 0;
    vector<bool> vis(n);
    for (int i = 0; i < n; ++i) {
        if (!vis[i]) {
            queue<int> q;
            q.push(i);
            vis[i] = true;
            vector<int> component = {i};
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                for (int v: g[u]) {
                    if (!vis[v]) {
                        vis[v] = true;
                        q.push(v);
                        component.push_back(v);
                    }
                }
            }
            bool bamboo = false;
            for (int j: component) {
                if (d[j] == 1) {
                    bamboo = true;
                    break;
                }
            }
            if (bamboo) {
                bamboos++;
            } else {
                cycles++;
            }
        }
    }
    cout << cycles + min(bamboos, 1) << ' ' << cycles + bamboos << '\n';
}

int main() {
    int t;
    cin >> t;
    for (int _ = 0; _ < t; ++_) {
        solve();
    }
}

/*
         `)
        _ \
      (( }/  ,_
      )))__ /
     (((---'
       \ '
        )|____.---- )
       / \ `       (
      / ' \ `      )
     /  '  \  `   /
    /   '       _/
   /   _!____.-'
  /_.-'/    \
     |`_    |`_
*/
#include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> ipair;

const int MAXN = 200200;
const int MAXK = MAXN;
const int MOD = 1000000007;

inline int add(int a, int b) {
	return (a + b >= MOD ? a + b - MOD : a + b);
}

inline int mul(int a, int b) {
	return 1LL * a * b % MOD;
}

int n, m, k;
int arr[MAXN], brr[MAXN], cnt[MAXK];

void build() {
	sort(arr, arr + n);
	memcpy(brr, arr, sizeof(int) * n);
	k = unique(arr, arr + n) - arr;
	for (int j = 0; j < k; ++j)
		cnt[j] = upper_bound(brr, brr + n, arr[j]) - lower_bound(brr, brr + n, arr[j]);
}

inline void push(stack<ipair> &S, int x) {
	S.emplace(x, mul(x, S.empty() ? 1 : S.top().second));
}

int solve() {
	if (k < m) return 0;
	stack<ipair> S1, S2;
	for (int j = 0; j < m; ++j)
		push(S1, cnt[j]);
	int ans = 0;
	for (int j = m; j <= k; ++j) {
		if (arr[j - 1] - arr[j - m] == m - 1)
			ans = add(ans, mul(S1.empty() ? 1 : S1.top().second, S2.empty() ? 1 : S2.top().second));
		if (S2.empty()) {
			for (; !S1.empty(); S1.pop())
				push(S2, S1.top().first);
		}
		S2.pop();
		push(S1, cnt[j]);
	}
	return ans;
}

int main() {
	int t; cin >> t;
	while (t--) {
		cin >> n >> m;
		for (int i = 0; i < n; ++i)
			cin >> arr[i];
		build();
		cout << solve() << endl;
	}
}

#include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> ipair;

const int MAXN = 200200;

int n;
vector<ipair> gr[MAXN];
vector<int> res;
queue<int> qu;
int par[MAXN], ipar[MAXN], deg[MAXN], hard[MAXN];

void init() {
	res.clear();
	while (!qu.empty()) qu.pop();
	memset(deg, 0, sizeof(int) * n);
	memset(hard, 0, sizeof(int) * n);
	for (int v = 0; v < n; ++v)
		gr[v].clear();
}

void dfs(int v, int p, int ip) {
	par[v] = p;
	ipar[v] = ip;
	for (auto [u, i]: gr[v]) {
		if (u == p) continue;
		dfs(u, v, i);
		++deg[v];
		hard[v] += (deg[u] > 0);
	}
}

void build() {
	dfs(0, -1, -1);
}

bool rempar(int v) {
	int u = par[v];
	if (u == -1) return true;
	par[v] = -1;
	res.push_back(ipar[v]);
	--deg[u], --hard[u];
	if (deg[u]) {
		if (!hard[u]) qu.push(u);
		return true;
	}
	if (par[u] == -1) return false;
	--hard[par[u]];
	if (!hard[par[u]]) qu.push(par[u]);
	return true;
}

bool solve() {
	if (n % 3) return false;
	for (int v = 0; v < n; ++v)
		if (!hard[v] && deg[v]) qu.push(v);
	while (!qu.empty()) {
		int v = qu.front(); qu.pop();
		if (deg[v] > 2) return false;
		if (deg[v] == 2) {
			if (!rempar(v)) return false;
		} else if (deg[v] == 1) {
			if (par[v] == -1) return false;
			for (auto [u, i]: gr[par[v]]) {
				if (u == par[par[v]] || u == v || par[u] == -1) continue;
				if (!deg[u]) return false;
				res.push_back(i);
				par[u] = -1;
			}
			if (!rempar(par[v])) return false;
		}
	}
	return true;
}

int main() {
	int t; cin >> t;
	while (t--) {
		cin >> n, init();
		for (int i = 1; i < n; ++i) {
			int v, u; cin >> v >> u, --v, --u;
			gr[v].emplace_back(u, i);
			gr[u].emplace_back(v, i);
		}
		build();
		if (!solve()) {
			cout << -1 << endl;
			continue;
		}
		cout << res.size() << endl;
		for (int id: res)
			cout << id << ' ';
		cout << endl;
	}
}