package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var n int
		var a, b string
		fmt.Fscan(in, &n, &a, &b)

		var dir [20][20]bool
		var used [20]bool
		var undir [20][20]bool

		for i := 0; i < n; i++ {
			u := int(a[i] - 'a')
			v := int(b[i] - 'a')
			if u == v {
				continue
			}
			dir[u][v] = true
			used[u] = true
			used[v] = true
			undir[u][v] = true
			undir[v][u] = true
		}

		ans := 0
		var vis [20]bool

		for s := 0; s < 20; s++ {
			if !used[s] || vis[s] {
				continue
			}

			queue := make([]int, 0, 20)
			comp := make([]int, 0, 20)
			queue = append(queue, s)
			vis[s] = true

			for head := 0; head < len(queue); head++ {
				u := queue[head]
				comp = append(comp, u)
				for v := 0; v < 20; v++ {
					if undir[u][v] && !vis[v] {
						vis[v] = true
						queue = append(queue, v)
					}
				}
			}

			m := len(comp)
			if m == 1 {
				continue
			}

			pos := make([]int, 20)
			for i := 0; i < 20; i++ {
				pos[i] = -1
			}
			for i, v := range comp {
				pos[v] = i
			}

			inMask := make([]uint32, m)
			outMask := make([]uint32, m)

			for i, u := range comp {
				for v := 0; v < 20; v++ {
					if dir[u][v] {
						j := pos[v]
						if j >= 0 {
							outMask[i] |= 1 << j
							inMask[j] |= 1 << i
						}
					}
				}
			}

			limit := 1 << m
			acyclic := make([]uint8, limit)
			acyclic[0] = 1
			best := 0

			for mask := 1; mask < limit; mask++ {
				smask := uint32(mask)
				x := smask
				ok := false
				for x != 0 {
					lsb := x & -x
					i := bits.TrailingZeros32(lsb)
					prev := mask ^ int(lsb)
					if acyclic[prev] == 1 {
						if (outMask[i]&smask) == 0 || (inMask[i]&smask) == 0 {
							ok = true
							break
						}
					}
					x -= lsb
				}
				if ok {
					acyclic[mask] = 1
					pc := bits.OnesCount32(smask)
					if pc > best {
						best = pc
					}
				}
			}

			fvs := m - best
			ans += (m - 1) + fvs
		}

		fmt.Fprintln(out, ans)
	}
}