Problem:
Score : 400 points

Problem Statement

There are N people standing in a queue from west to east.

Given is a string S of length N representing the directions of the people.
The i-th person from the west is facing west if the i-th character of S is L, and east if that character of S is R.

A person is happy if the person in front of him/her is facing the same direction.
If no person is standing in front of a person, however, he/she is not happy.

You can perform the following operation any number of times between 0 and K (inclusive):

Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.

What is the maximum possible number of happy people you can have?

Constraints

N is an integer satisfying 1 \leq N \leq 10^5.

K is an integer satisfying 1 \leq K \leq 10^5.

|S| = N

Each character of S is L or R.

Input

Input is given from Standard Input in the following format:

N K
S

Output

Print the maximum possible number of happy people after at most K operations.

Sample Input 1

6 1
LRLRRL

Sample Output 1

3

If we choose (l, r) = (2, 5), we have LLLRLL, where the 2-nd, 3-rd, and 6-th persons from the west are happy.

Sample Input 2

13 3
LRRLRLRRLRLLR

Sample Output 2

9

Sample Input 3

10 1
LLLLLRRRRR

Sample Output 3

9

Sample Input 4

9 2
RRRLRLRLL

Sample Output 4

7

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.io.*;
import java.util.*;

public class Main {
	static long[] listS, listT;

	public static void main(String[] args) {
		try {
			BufferedReader br = createBufferedReader();
			String line = br.readLine();
			StringTokenizer st = new StringTokenizer(line, " ");
			final int n = Integer.parseInt(st.nextToken());
			final int k = Integer.parseInt(st.nextToken());
			String s = br.readLine();
			int max = numberOfHappy(s);
			for (int i = 0; i < k; i++) {
				String maxS = "";
				for (int l = 0; l < n; l++) {
					for (int r = l; r < n; r++) {
						String changed = changeString(s, l, r);
						int happy = numberOfHappy(changed);
						if (happy > max) {
							maxS = changed;
							max = happy;
						}
					}
				}
				if (maxS.equals("")) {
					break;
				}
				s = maxS;
			}
			System.out.println(max);
		} catch (IOException ioe) {
			ioe.printStackTrace();
		} catch (IllegalArgumentException iae) {
			iae.printStackTrace();
			System.err.println("入力が正しくありません。");
		}
	}

	private static int numberOfHappy(final String s) {
		int result = 0, n = s.length();
		for (int i = 0; i < n; i++) {
			if (i != n - 1 && s.charAt(i) == 'R' && s.charAt(i + 1) == 'R') {
				result++;
			} else if (i != 0 && s.charAt(i) == 'L' && s.charAt(i - 1) == 'L') {
				result++;
			}
			s.charAt(i);
		}
		return result;
	}

	private static String changeString(final String s, final int l, final int r) {
		char[] changedStr = s.toCharArray();
		int n = s.length();
		if (l == r) {
			changedStr[l] = changeChar(changedStr[l]);
			return new String(changedStr);
		}
		for (int i = 0; i <= r - l; i++) {
			if (l + i > r - i) {
				break;
			}
			char left = changedStr[l + i];
			char right = changedStr[r - i];
			changedStr[l + i] = changeChar(right);
			changedStr[r - i] = changeChar(left);
		}
		return new String(changedStr);
	}

	private static char changeChar(final char c) {
		if (c == 'L') {
			return 'R';
		}
		if (c == 'R') {
			return 'L';
		}
		return ' ';
	}

	// 以下問題問わずに共通部分
	// 標準入力の BufferedReader を返す.
	private static BufferedReader createBufferedReader() {
		InputStreamReader isr = new InputStreamReader(System.in);
		return new BufferedReader(isr);
	}
}