import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Solution to Ducks in a Row
 * 
 * @author vanb
 */
public class ducks_vanb
{
    private static Scanner sc;
    private static PrintStream ps;
    
    /** The desired minimum length of a run of Ducks */
    private int n;
    
    /** The desired number of at-least-n length runs of Ducks */
    private int k;
    
    /**
     * A State captures two numbers: The length of the current run of Ducks, 
     * and the number of at-least-n length segments we've seen.
     * 
     * @author vanb
     */
    private class State implements Comparable<State>
    {
        /** The length of the current run of Ducks */
        public int run;
        
        /** The number of at-least-n length segments we've seen */
        public int num;
        
        /**
         * Create a State.
         * 
         * @param run The length of the current run of Ducks
         * @param num The number of at-least-n length segments we've seen
         */
        public State( int run, int num )
        {
            this.run = run;
            this.num = num;
        }

        @Override
        /**
         * Compare this state to another state.
         * 
         * @param other Another State
         * @return Standard for compareTo: <0, 0, or >0
         */
        public int compareTo( State other )
        {
            // We always want to maximize the number of segments
            int diff = other.num - num;
            if( diff==0 )
            {
                // If the number of segments are the same, then it's tricky.
                // If the last run is also the last segment, well, it's better 
                // to add to the shorter one to get to the next number of segments.
                // If they're both too short, take the longer one.
                diff = (Math.max( run, other.run )<n) ? other.run - run : run - other.run; 
            }
            return diff;
        }  
        
        /**
         * A pretty String for debugging.
         * 
         * @return A pretty String for debugging
         */
        public String toString()
        {
            return "[run=" + run + ", num=" + num + "]";
        }
    }
    
    /**
     * Is one state better than another?
     * 
     * @param s0 A State
     * @param s1 Another State
     * @return The better of the two States, or null if both are null.
     */
    private State better( State s0, State s1 )
    {
        State best = null;
        
        // If one is null, the other is obviously the best.
        if( s0==null ) best = s1;
        else if( s1==null ) best = s0;
        
        // Otherwise, use the compareTo method to distinguish.
        else best = s0.compareTo( s1 ) < 0 ? s0 : s1;
        
        return best;
    }
    
    /**
     * Do it!
     */
    private void doit()
    {
        n = sc.nextInt();
        k = sc.nextInt();
        
        char row[] = sc.next().toCharArray();
        
        int m = row.length;
        
        // flip[i][i] is the best State you can achieve up to character i with j flips,
        // if you flip character i.
        State flip[][] = new State[m][m+1];
        
        // Obviously, noflip is the same thing, but if you don't flip character i.
        State noflip[][] = new State[m][m+1];
        
        if( row[0]=='D' )
        {
            // If the first character is a Duck, then 1 flip yields 
            // a Goose. That's a run of length 0 with 0 n-length segments.
            flip[0][1] = new State( 0, 0 );
            
            // No flip? That's a run of length 1, and you've seen 1 n-length segment if n==1.
            noflip[0][0] = new State( 1, n==1?1:0 );            
        }
        else
        {
            // It's a Goose. Flip it? That's a run of length 1, and you've seen 1 n-length segment if n==1.
            flip[0][1] = new State( 1, n==1?1:0 );
            
            // No flip? That's a run of length 0 with 0 n-length segments.
            noflip[0][0] = new State( 0, 0 );        
        }
        
        // OK, we've figured out the best states for the first character,
        // how about the rest of them?
        int min = Integer.MAX_VALUE;
        if( m==1 && n==1 && k==1 ) min = (row[0]=='D') ? 0 : 1;
        for( int i=1; i<m; i++ ) 
        {           
            // If it's a Duck
            if( row[i]=='D' )
            {
                // Go through all of the possible number of flips
                for( int j=0; j<=m/2; j++ )
                {
                    // Flip
                    if( j>0 )
                    {
                        State s = better( flip[i-1][j], noflip[i-1][j-1] );
                        if( s!=null )
                        {
                            flip[i][j] = new State( 0, s.num );
                        }
                    }
                    
                    // Don't flip
                    State s = better( flip[i-1][j], noflip[i-1][j] );
                    if( s!=null )
                    {
                        noflip[i][j] = new State( s.run+1, (s.run==n-1) ? s.num+1 : s.num );
                        if( noflip[i][j].num==k && j<min ) min = j; 
                    }
                }
            }
            else
            {
                // It's a Goose
                for( int j=0; j<=m/2; j++ )
                {
                    // Flip
                    if( j>0 )
                    {
                        State s = better( flip[i-1][j], noflip[i-1][j-1] );
                        if( s!=null )
                        {
                            flip[i][j] = new State( s.run+1, (s.run==n-1) ? s.num+1 : s.num );
                            if( flip[i][j].num==k && j<min ) min = j; 
                        }
                    }
                    
                    // Don't flip
                    State s = better( flip[i-1][j], noflip[i-1][j] );
                    if( s!=null )
                    {
                        noflip[i][j] = new State( 0, s.num );
                    }
                }
            }
        }
        
        ps.println( min==Integer.MAX_VALUE ? -1 : min );
    }
     
    /**
     * Main!
     * 
     * @param args Command-line args (unused)
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        new ducks_vanb().doit();
    }

}