#include <iostream>
#include <fstream>
#include <algorithm>
#define maxn 17000
using namespace std;
ifstream f("substr.in");
ofstream g("substr.out");

struct suffix{
    int nr[2];
    int p;
};
int N, K, lg;
char S[maxn];
int P[20][maxn], v[maxn];
suffix L[maxn];
bool cmp(const suffix &A, const suffix &B) {
    if (A.nr[0] == B.nr[0]) {
        return A.nr[1] < B.nr[1];
    }
    return A.nr[0] < B.nr[0];
}
void suffix_array(char *S) {
    for (int i = 0; i < N; ++i) {
        P[0][i] = S[i];
    }
    int cnt = 1;
    for (lg = 1; (1 << lg) <= N; ++lg) {
        for (int i = 0; i < N; ++i) {
            L[i].nr[0] = P[lg - 1][i];
            if (i + cnt < N) {
                L[i].nr[1] = P[lg - 1][i + cnt];
            } else {
                L[i].nr[1] = -1;
            }
            L[i].p = i;
        }
        sort(L, L + N, cmp);
        for (int i = 0; i < N; ++i) {
            if (i > 0 && L[i].nr[0] == L[i - 1].nr[0] && L[i].nr[1] == L[i - 1].nr[1]) {
                P[lg][L[i].p] = P[lg][L[i - 1].p];
            } else {
                P[lg][L[i].p] = i;
            }
        }
        cnt *= 2;
    }

}
int LCP(int x, int y) {
    int ans = 0;
    if (x == y) {
        return N - x;
    }
    for (int i = lg - 1; i >= 0 && x < N && y < N; --i) {
        if (P[i][x] == P[i][y]) {
            x += (1 << i);
            y += (1 << i);
            ans += (1 << i);
        }
    }
    return ans;
}
int main()
{
    int ans = 0;
    f >> N >> K;
    f >> S;
    if (K == 1) {
        g << N;
        return 0;
    }
    suffix_array(S);
    for (int i = 0; i <= N - K; ++i) {
        ans = max(ans, LCP(L[i].p, L[i + K - 1].p));
    }
    g << ans;
    return 0;
}