#include <bits/stdc++.h>
using ll = long long;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define all(v) begin(v), end(v)
using namespace std;

template <size_t N>
struct BitSet {
    array<uint64_t, (N + 64 - 1) / 64> bits;
    BitSet() { fill(all(bits), 0); }
    BitSet(const uint64_t &val) { fill(all(bits), val); }
    bool operator[](size_t i) const { return bits[i / 64] >> (i % 64) & 1; }
    void set(size_t i, bool val = true) {
        if (val) bits[i / 64] |= 1ull << (i % 64);
        else bits[i / 64] &= ~(1ull << (i % 64));
    }

    BitSet operator~() const {
        BitSet res;
        rep(i, bits.size()) res.bits[i] = ~bits[i];
        return res;
    }
    BitSet &operator&=(const BitSet &rhs) {
        rep(i, bits.size()) bits[i] &= rhs.bits[i];
        return *this;
    }
    BitSet &operator|=(const BitSet &rhs) {
        rep(i, bits.size()) bits[i] |= rhs.bits[i];
        return *this;
    }
    BitSet &operator^=(const BitSet &rhs) {
        rep(i, bits.size()) bits[i] ^= rhs.bits[i];
        return *this;
    }
    BitSet &operator+=(const BitSet &rhs) {
        uint64_t carry = 0;
        rep(i, bits.size()) {
            uint64_t tmp = bits[i];
            bits[i] += rhs.bits[i] + carry;
            carry = (bits[i] < tmp) || (carry && bits[i] == tmp);
        }
        return *this;
    }
    BitSet &operator<<=(size_t n) {
        assert(n < 64);
        rrep(i, bits.size()) {
            bits[i] <<= n;
            if (i) bits[i] |= bits[i - 1] >> (64 - n);
        }
        return *this;
    }
    BitSet operator&(const BitSet &rhs) const { return BitSet(*this) &= rhs; }
    BitSet operator|(const BitSet &rhs) const { return BitSet(*this) |= rhs; }
    BitSet operator^(const BitSet &rhs) const { return BitSet(*this) ^= rhs; }
    BitSet operator+(const BitSet &rhs) const { return BitSet(*this) += rhs; }
    BitSet operator<<(size_t n) const { return BitSet(*this) <<= n; }

    friend ostream &operator<<(ostream &os, const BitSet &bs) {
        rep(i, N) os << bs[i];
        return os;
    }
};

using BS = BitSet<1001>;
BS I[26];
int n, m;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n >> m;
    string s, t;
    cin >> s >> t;

    auto edit_distance = [&](const auto &s, const auto &t) -> int {
        int n = s.size(), m = t.size();
        rep(i, n) I[s[i] - 'a'].set(i + 1);
        int d = n;
        BS rp(uint64_t(-1)), rn;
        rp.set(0, false);
        rep(j, m) {
            int ci = t[j] - 'a';
            auto d0 = (((I[ci] & rp) + rp) ^ rp) | I[ci] | rn;
            auto cn = rp & d0;
            auto cp = rn | ~(rp | d0);
            rn = (cp << 1) & d0;
            rp = (cn << 1) | ((~cp << 1) & ~d0);
            d += cp[n] - cn[n];
        }
        return d;
    };
    cout << edit_distance(s, t) << endl;
    return 0;
}