1383A. String Transformation 1

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 p1,p2,…,pk (k≥1;1≤pi≤n;pi≠pj if i≠j)
of A such that Ap1=Ap2=…=Apk=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
p1,p2,…,pk to letter y. More formally: for each i (1≤i≤k) Koa sets
Api=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≤t≤10) — the number of test cases. Description of the test cases
follows.

The first line of each test case contains one integer n (1≤n≤105) —
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
105.

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.

输入

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

输出

2
-1
3
2
-1

这道题乍一看好像可以取巧，我尝试了发现自己的推测太naive，就不说明错误的做法了。官方给了一个图论的解法
s1串中的各个顶点u到s2串中对应的顶点v建立图
每个部分的最好情况是每个部分的顶点数-1，取加和就得到了答案
解法的证明：
Each connected component require at least n−1 operations (because they are connected). Since there are no cycles in the graph a topological order exists. Find one and select each pair of consecutive nodes in this order as the list of operations.
每个连通的部分需要至少n-1个步骤相连。由于图中不存在环，则有拓扑顺序存在。

为什么双向建边：双向建边可以确保处于一个连通部分的点不会被忽略掉，因为每步操作都会减去没被标记过的点作为答案

#include <bits/stdc++.h>

using namespace std;
bool marks[25];
vector<int> rec[25];
void dfs(int i)
{
    marks[i]=1;
    for(auto v : rec[i])
        if(!marks[v])dfs(v);
}
int main()
{
    ios::sync_with_stdio(0);
    int t;
    cin>>t;
    while(t--){
        int n;
        memset(marks,0,sizeof marks);
        for(int i=0;i<20;i++)rec[i].clear();
        string s1,s2;
        cin>>n;
        cin>>s1>>s2;
        int flag=1;
        for(int i=0;i<n;i++){
            if(s1[i]>s2[i]){
                flag=0;break;
            }
            rec[s1[i]-'a'].push_back(s2[i]-'a');
            rec[s2[i]-'a'].push_back(s1[i]-'a');//加入边
        }
        if(!flag){
            cout<<-1<<endl;
        }
        else{
          int ans=20;
          for(int i=0;i<20;i++){
            if(!marks[i]){
                dfs(i);
                ans--;
            }
          }
          cout<<ans<<endl;
    }

    }
}