#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <stack>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int N = 150010, A = 26;

namespace SAM {

struct Node {
  int fail, len;
  int ch[A];
} P[N << 2];

int root, top;

void init() {
  root = top = 1;
}

int ins(int o, int c) {
  int p = ++top;
  P[p].len = P[o].len + 1;

  while (o && !P[o].ch[c]) {
    P[o].ch[c] = p;
    o = P[o].fail;
  }
  if (!o) {
    P[p].fail = root;
  } else {
    int q = P[o].ch[c];
    if (P[q].len == P[o].len + 1) {
      P[p].fail = q;
    } else {
      int nq = ++top;
      memcpy(P + nq, P + q, sizeof(Node));
      P[nq].len = P[o].len + 1;
      P[q].fail = P[p].fail = nq;
      while (o && P[o].ch[c] == q) {
        P[o].ch[c] = nq;
        o = P[o].fail;
      }
    }
  }
  return p;
}

}

int n, k;
char s[N], t[N];
int tag[N << 2];
ll ans;
vector<int> ch[N << 2];

void dfs(int u) {
  int x0 = 0, x1 = 0;
  if (tag[u] > 0) x0 += tag[u];
  else x1 += -tag[u];
  for (int v : ch[u]) {
    dfs(v);
    if (tag[v] > 0) x0 += tag[v];
    else x1 += -tag[v];
  }
  ans -= min(k, SAM::P[u].len) * (ll)min(x0, x1);
  tag[u] = x0 - x1;
}

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  cin >> n >> k >> s >> t;
  SAM::init();
  int o = SAM::root;
  for (int i = n - 1; i >= 0; --i) {
    o = SAM::ins(o, s[i] - 'a');
    if (i <= n - k)
      tag[o] = 1;
  }
  for (int i = n - 1; i >= 0; --i) {
    o = SAM::ins(o, t[i] - 'a');
    if (i <= n - k)
      tag[o] = -1;
  }
  for (int i = 2; i <= SAM::top; ++i) {
    ch[SAM::P[i].fail].push_back(i);
  }
  ans = (n - k + 1LL) * k;
  dfs(1);
  cout << ans << '\n';

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}