#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define INF LLONG_MAX
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

int main() {

    fastio;

    ll n,k;
    vector<char> a(100);
    ll dp[100][100][3];

    cin >> n >> k;
    for(ll i = 1; i <= n; i++) cin >> a[i];

    // OPTIMAL SUB-PROBLEM :

    // dp[i][j][0] = maximum number of games bessie can win if we play HOOF at first i games and k = j
    // dp[i][j][1] = maximum number of games bessie can win if we play PAPERS at first i games and k = j
    // dp[i][j][2] = maximum number of games bessie can win if we play SCISSORS at first i games and k = j

    // BASE CASE :

    if(a[1] == 'H') {
        for(ll j = 1; j <= k ;j++) dp[1][j][1] = 1;
        for(ll j = 1; j <= k; j++) dp[1][j][0] = 0;
        for(ll j = 1; j <= k; j++) dp[1][j][2] = 0;
    }

    if(a[1] == 'S') {
        for(ll j = 1; j <= k ;j++) dp[1][j][0] = 1;
        for(ll j = 1; j <= k; j++) dp[1][j][1] = 0;
        for(ll j = 1; j <= k; j++) dp[1][j][2] = 0;
    }

    if(a[1] == 'P') {
        for(ll j = 1; j <= k ;j++) dp[1][j][1] = 0;
        for(ll j = 1; j <= k; j++) dp[1][j][0] = 0;
        for(ll j = 1; j <= k; j++) dp[1][j][2] = 1;
    }


    // RECURSIVE RELATION :

    for(ll i = 1; i <= n; i++){
        for(ll j = 1; j <= 1; j++){

            if(a[i] == 'H') {

                dp[i][j][1] = 1 + max(dp[i-1][k-1][0],max(dp[i-1][k-1][2] , dp[i-1][k][1]));
                dp[i][j][0] = max(dp[i-1][k-1][1],max(dp[i-1][k-1][2] , dp[i-1][k][0]));
                dp[i][j][2] = max(dp[i-1][k-1][0],max(dp[i-1][k-1][1] , dp[i-1][k][2]));

            }

            if(a[i] == 'S') {

                dp[i][j][0] = 1 + max(dp[i-1][k-1][1],max(dp[i-1][k-1][2] , dp[i-1][k][0]));
                dp[i][j][1] = max(dp[i-1][k-1][0],max(dp[i-1][k-1][2] , dp[i-1][k][1]));
                dp[i][j][2] = max(dp[i-1][k-1][0],max(dp[i-1][k-1][1] , dp[i-1][k][2]));
            }

            if(a[i] == 'P') {

                dp[i][j][2] = 1 + max(dp[i-1][k-1][0],max(dp[i-1][k-1][1] , dp[i-1][k][2]));
                dp[i][j][0] = max(dp[i-1][k-1][1],max(dp[i-1][k-1][2] , dp[i-1][k][0]));
                dp[i][j][1] = max(dp[i-1][k-1][0],max(dp[i-1][k-1][2] , dp[i-1][k][1]));
            }
        }
    }

    // OPTIMAL SOLUTION :

    cout << max(dp[n][k][0] , max(dp[n][k][1] , dp[n][k][2]));

    return 0;
}