#include <algorithm>
#include <fstream>

using namespace std;

#define Input "substr.in"
#define Output "substr.out"

#define Dim 17027
#define Log 20

struct suffix {

    int f, s, p;
};

char s[Dim];
int n, k, sol, p[Log][Dim];
int p2, x[Dim];
suffix l[Dim];

//struct cmp {
//
//    bool operator()( const suffix &a, const suffix &b ) {
//
//        return (a.f < b.f) || (a.f == b.f && a.s < b.s);
//    }
//};
//
//struct cmp_2 {
//
//    bool operator()( const int &x, const int &y ) {
//
//        return P[cnt][x] < P[cnt][y];
//    }
//};
//
//int lcp( int x, int y ) {
//
//    int i, sol;
//
//    if( x == y )
//        return N - x;
//
//    sol = 0;
//    for( i = cnt; i >= 0 && x < N && y < N; --i )
//        if( P[i][x] == P[i][y] ) {
//
//            x += (1 << i);
//            y += (1 << i);
//            sol += (1 << i);
//        }
//
//    return sol;
//}

bool cmp(suffix a, suffix b) {
    if (a.f < b.f || (a.f == b.f && a.s < b.s))
        return true;
    return false;
}

bool cmp2(int a, int b) {
    if (p[p2][a] < p[p2][b])
        return true;
    return false;
}

int lcp(int x, int y) {
    int rez = 0;
    if (x == y)
        return n - x;
    for (int cnt = p2; cnt >= 0 && x < n && y < n; cnt--)
        if (p[cnt][x] == p[cnt][y]) {
            x += (1 << cnt); y += (1 << cnt);
            rez += (1 << cnt);
        }
    return rez;
}

int main() {

    ifstream fin( Input );
    ofstream fout( Output );

    int i, j;

    fin >> n >> k;
    fin.ignore( 1, '\n' );
    fin.getline( s, Dim );

////    for( i = 0; i < N; ++i ) {
////
////        L[i].f = A[i];
////        L[i].s = -1;
////        L[i].p = i;
////    }
//
////    sort( L, L + N, cmp() );
//
////    for( i = 0; i < N; ++i )
////        if( i > 0 && L[i].f == L[i - 1].f && L[i].s == L[i - 1].s )
////            P[0][L[i].p] = P[0][L[i - 1].p];
////        else
////            P[0][L[i].p] = i;
//
////    for( i = 0; i < N; ++i )
////        P[0][i] = A[i] - 'a';
////
////    for( i = 1; (1 << i) <= N; ++i ) {
////
////        for( j = 0; j < N; ++j ) {
////
////            L[j].f = P[i - 1][j];
////            if( j + (1 << (i - 1)) < N )
////                L[j].s = P[i - 1][j + (1 << (i - 1))];
////            else
////                L[j].s = -1;
////            L[j].p = j;
////        }
////
////        sort( L, L + N, cmp() );
////
////        for( j = 0; j < N; ++j )
////            if( j > 0 && L[j].f == L[j - 1].f && L[j].s == L[j - 1].s )
////                P[i][L[j].p] = P[i][L[j - 1].p];
////            else
////                P[i][L[j].p] = j;
////    }
//
//    for (i = 0; i < N; i++)
//        P[0][i] = A[i] - 'a';
//
//    for (i = 1; (1 << i) <= N; i++) {
//        for (j = 0; j < N; j++) {
//            L[j].f = P[i - 1][j];
//            L[j].s = P[i - 1][j + (1 << (i - 1))];
//            L[j].p = j;
//        }
//
//        sort(L, L + N, cmp());
//
//        P[i][L[0].p] = 0;
//        for (j = 1; j < N; j++)
//            if (L[j].f == L[j - 1].f && L[j].s == L[j - 1].s)
//                P[i][L[j].p] = P[i][L[j - 1].p];
//            else
//                P[i][L[j].p] = j;
//    }
//
//    cnt = i - 1;
//
////    for( int i = 0; i < N; ++i )
////        fout << L[i].p << "\n";
//
////    fout << cnt;
//
//    for( i = 0; i < N; ++i )
//        ord[i] = i;
//    sort( ord, ord + N, cmp_2() );
//
////    for( int i = 0; i < N; ++i )
////        fout << ord[i] << "\n";
//
////    for( int i = 0; i < N; ++i ) {
////
////        for( int j = ord[i]; j < N; ++j )
////            fout << A[j];
////        fout << "\n";
////    }
//
////    for( int i = 0; i < N - K; ++i )
////        aux = lcp( ord[i], ord[i + K - 1] );
//
//    for( i = 0; i < N - K; ++i )
//        Sol = max( Sol, lcp( ord[i], ord[i + K - 1] ) );
//
//    fout << Sol;

    for (i = 0; i < n; i++)
        p[0][i] = s[i] - 'a';

    for (i = 1; (1 << i) <= n; i++) {
        for (j = 0; j < n; j++) {
            l[j].f = p[i - 1][j];
            l[j].s = p[i - 1][j + (1 << (i - 1))];
            l[j].p = j;
        }

        sort(l, l + n, cmp);

        p[i][l[0].p] = 0;
        for (j = 1; j < n; j++)
            if (l[j].f == l[j - 1].f && l[j].s == l[j - 1].s)
                p[i][l[j].p] = p[i][l[j - 1].p];
            else
                p[i][l[j].p] = j;
    }

    p2 = i - 1;

    for (i = 0; i < n; i++)
        x[i] = i;

    sort(x, x + n, cmp2);

    for (i = 0; i < n - k; i++) {
        sol = max(sol, lcp(x[i], x[i + k - 1]));
    }

    fout << sol;

    fin.close();
    fout.close();

    return 0;
}