Note that the only difference between String Transformation 1 and String Transformation 2 is in the move Koa does. In this version the letter $y$ Koa selects must be strictly greater alphabetically than $x$ (read statement for better understanding). You can make hacks in these problems independently.

Koa the Koala has two strings $A$ and $B$ of the same length $n$ ($|A|=|B|=n$) consisting of the first $20$ lowercase English alphabet letters (ie. from a to t).

In one move Koa:

  selects some subset of positions $p_1, p_2, \ldots, p_k$ ($k \ge 1; 1 \le p_i \le n; p_i \neq p_j$ if $i \neq j$) of $A$ such that $A_{p_1} = A_{p_2} = \ldots = A_{p_k} = x$ (ie. all letters on this positions are equal to some letter $x$).

  selects a letter $y$ (from the first $20$ lowercase letters in English alphabet) such that $y>x$ (ie. letter $y$ is strictly greater alphabetically than $x$).

  sets each letter in positions $p_1, p_2, \ldots, p_k$ to letter $y$. More formally: for each $i$ ($1 \le i \le k$) Koa sets $A_{p_i} = y$.

 Note that you can only modify letters in string $A$.

Koa wants to know the smallest number of moves she has to do to make strings equal to each other ($A = B$) or to determine that there is no way to make them equal. Help her!


-----Input-----

Each test contains multiple test cases. The first line contains $t$ ($1 \le t \le 10$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains one integer $n$ ($1 \le n \le 10^5$) — the length of strings $A$ and $B$.

The second line of each test case contains string $A$ ($|A|=n$).

The third line of each test case contains string $B$ ($|B|=n$).

Both strings consists of the first $20$ lowercase English alphabet letters (ie. from a to t).

It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.


-----Output-----

For each test case:

Print on a single line the smallest number of moves she has to do to make strings equal to each other ($A = B$) or $-1$ if there is no way to make them equal.


-----Example-----
Input
5
3
aab
bcc
4
cabc
abcb
3
abc
tsr
4
aabd
cccd
5
abcbd
bcdda

Output
2
-1
3
2
-1



-----Note-----  In the $1$-st test case Koa:   selects positions $1$ and $2$ and sets $A_1 = A_2 = $ b ($\color{red}{aa}b \rightarrow \color{blue}{bb}b$).  selects positions $2$ and $3$ and sets $A_2 = A_3 = $ c ($b\color{red}{bb} \rightarrow b\color{blue}{cc}$). 

  In the $2$-nd test case Koa has no way to make string $A$ equal $B$.

  In the $3$-rd test case Koa:   selects position $1$ and sets $A_1 = $ t ($\color{red}{a}bc \rightarrow \color{blue}{t}bc$).  selects position $2$ and sets $A_2 = $ s ($t\color{red}{b}c \rightarrow t\color{blue}{s}c$).  selects position $3$ and sets $A_3 = $ r ($ts\color{red}{c} \rightarrow ts\color{blue}{r}$).

Difficulty: competition

Starter code:

Solutions:
import sys
input = lambda: sys.stdin.readline().rstrip()
T = int(input())
for _ in range(T):
    N = int(input())
    A = [ord(a) - 97 for a in input()]
    B = [ord(a) - 97 for a in input()]
    X = [[0] * 20 for _ in range(20)]
    for a, b in zip(A, B):
        X[a][b] = 1
        if a > b:
            print(-1)
            break
    else:
        ans = 0
        for i in range(20):
            for j in range(i+1, 20):
                if X[i][j]:
                    ans += 1
                    for jj in range(j+1, 20):
                        if X[i][jj]:
                            X[j][jj] = 1
                    break
        print(ans)


import sys
input = sys.stdin.readline

t=int(input())
for tests in range(t):
    n=int(input())
    A=input().strip()
    B=input().strip()

    for i in range(n):
        if A[i]>B[i]:
            print(-1)
            break
    else:
        DICT=dict()

        for i in range(n):
            a=A[i]
            b=B[i]

            if a==b:
                continue

            if a in DICT:
                DICT[a].add(b)
            else:
                DICT[a]={b}

        #print(DICT)

        ANS=0

        for x in "abcdefghijklmnopqrst":
            if x in DICT and DICT[x]!=set():
                ANS+=1
                MIN=min(DICT[x])
                if MIN in DICT:
                    DICT[MIN]=DICT[MIN]|DICT[x]-{MIN}
                else:
                    DICT[MIN]=DICT[x]-{MIN}
        print(ANS)
            

    


import sys
input = sys.stdin.readline


class UnionFind:
    def __init__(self, n):
        self.parent = [-1] * n
        self.cnt = n

    def root(self, x):
        if self.parent[x] < 0:
            return x
        else:
            self.parent[x] = self.root(self.parent[x])
            return self.parent[x]

    def merge(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return
        if self.parent[x] > self.parent[y]:
            x, y = y, x
        self.parent[x] += self.parent[y]
        self.parent[y] = x
        self.cnt -= 1

    def is_same(self, x, y):
        return self.root(x) == self.root(y)

    def get_size(self, x):
        return -self.parent[self.root(x)]

    def get_cnt(self):
        return self.cnt


t = int(input())
alph = "abcdefghijklmnopqrstuvwxyz"
to_ind = {char: i for i, char in enumerate(alph)}


for _ in range(t):
    n = int(input())
    a = list(input())
    b = list(input())
    
    flag = False
    for i in range(n):
        if a[i] > b[i]:
            print(-1)
            flag = True
            break
    if flag:
        continue

    uf = UnionFind(26)
    for i in range(n):
        u = to_ind[a[i]]
        v = to_ind[b[i]]
        uf.merge(u, v)
    print(26 - uf.get_cnt())

import sys
readline = sys.stdin.readline

T = int(readline())
Ans = [None]*T
geta = 20
for qu in range(T):
    N = int(readline())
    A = list(map(lambda x: ord(x)-97, readline().strip()))
    B = list(map(lambda x: ord(x)-97, readline().strip()))
    if any(a > b for a, b in zip(A, B)):
        Ans[qu] = -1
        continue
    res = 0
    table = [[0]*geta for _ in range(geta)]
    for a, b in zip(A, B):
        if a != b:
            table[a][b] = 1
    
    for al in range(geta):
        if sum(table[al]):
            res += 1
            bl = table[al].index(1)
            for cl in range(bl+1, geta):
                table[bl][cl] = table[bl][cl] | table[al][cl]
    Ans[qu] = res
print('\n'.join(map(str, Ans)))