#include <bits/stdc++.h>
using namespace std;
const long long INF = numeric_limits<long long>::max() / 4;
struct MinCostMaxFlow {
  int N;
  vector<vector<long long> > cap, flow, cost;
  vector<int> found;
  vector<long long> dist, pi, width;
  vector<pair<int, int> > dad;
  MinCostMaxFlow(int N)
      : N(N),
        cap(N, vector<long long>(N)),
        flow(N, vector<long long>(N)),
        cost(N, vector<long long>(N)),
        found(N),
        dist(N),
        pi(N),
        width(N),
        dad(N) {}
  void AddEdge(int from, int to, long long cap, long long cost) {
    this->cap[from][to] = cap;
    this->cost[from][to] = cost;
  }
  void Relax(int s, int k, long long cap, long long cost, int dir) {
    long long val = dist[s] + pi[s] - pi[k] + cost;
    if (cap && val < dist[k]) {
      dist[k] = val;
      dad[k] = make_pair(s, dir);
      width[k] = min(cap, width[s]);
    }
  }
  long long Dijkstra(int s, int t) {
    fill(found.begin(), found.end(), false);
    fill(dist.begin(), dist.end(), INF);
    fill(width.begin(), width.end(), 0);
    dist[s] = 0;
    width[s] = INF;
    while (s != -1) {
      int best = -1;
      found[s] = true;
      for (int k = 0; k < N; k++) {
        if (found[k]) continue;
        Relax(s, k, cap[s][k] - flow[s][k], cost[s][k], 1);
        Relax(s, k, flow[k][s], -cost[k][s], -1);
        if (best == -1 || dist[k] < dist[best]) best = k;
      }
      s = best;
    }
    for (int k = 0; k < N; k++) pi[k] = min(pi[k] + dist[k], INF);
    return width[t];
  }
  pair<long long, long long> GetMaxFlow(int s, int t) {
    long long totflow = 0, totcost = 0;
    while (long long amt = Dijkstra(s, t)) {
      totflow += amt;
      for (int x = t; x != s; x = dad[x].first) {
        if (dad[x].second == 1) {
          flow[dad[x].first][x] += amt;
          totcost += amt * cost[dad[x].first][x];
        } else {
          flow[x][dad[x].first] -= amt;
          totcost -= amt * cost[x][dad[x].first];
        }
      }
    }
    return make_pair(totflow, totcost);
  }
};
int main() {
  long long n, k, x, y, i, j, src, sink, mat[100][100];
  string str1, str2;
  cin >> n >> k;
  cin >> str1 >> str2;
  for (i = 0; i < n; i++) {
    if (isupper(str1[i]))
      x = str1[i] - 'A' + 26;
    else
      x = str1[i] - 'a';
    if (isupper(str2[i]))
      y = str2[i] - 'A' + 26;
    else
      y = str2[i] - 'a';
    mat[x][y]++;
  }
  MinCostMaxFlow mf(2 * k + 2);
  src = 2 * k;
  sink = src + 1;
  for (i = 0; i < k; i++) {
    for (j = 0; j < k; j++) {
      mf.AddEdge(i, j + k, 1, 2000007 - mat[i][j]);
    }
  }
  for (i = 0; i < k; i++) {
    mf.AddEdge(src, i, 1, 0);
    mf.AddEdge(i + k, sink, 1, 0);
  }
  pair<long long, long long> p = mf.GetMaxFlow(src, sink);
  cout << p.first * 2000007 - p.second << endl;
  char ch;
  for (i = 0; i < k; i++) {
    for (j = 0; j < k; j++) {
      if (mf.flow[i][j + k]) {
        if (j >= 26) {
          ch = j - 26 + 'A';
          cout << ch;
          break;
        } else {
          ch = j + 'a';
          cout << ch;
          break;
        }
      }
    }
  }
  return 0;
}
