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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <algorithm>
#include <iostream>
#include <vector>

// 同じ方向を向いて連続するx人のうち、x-1人が幸福である
// パターンA：端を含まない連続するx人を操作すると、幸福な人は2人増える（x-1 -> x+1）
// パターンB：端を含む連続するx人を操作すると、幸福な人は1人増える（x-1 -> x）
// ⇒ 幸福な人数を最大にしたいので、まずAの場合を可能な限り行い、次にBの場合を行う
int main() {
  size_t N = 0;  // 人数
  size_t K = 0;  // 操作回数の上限
  std::cin >> N >> K;

  std::vector<char> S(N);
  for (size_t i = 0; i < N; ++i) {
    std::cin >> S[i];
  }

  // 初期状態を調べる
  size_t pair_count = 0;  // LとRの連続部分のペアの個数
  size_t happiness = 0;  // 幸福度
  auto head_iter = S.cbegin();  // 連続部分の先頭のイテレータ
  for (auto iter = ++S.cbegin(); iter != S.cend(); ++iter) {
    if (*iter != *head_iter) {
      if (*head_iter != S.front()) pair_count++;
      happiness += (iter - head_iter) - 1;
      head_iter = iter;
    }
  }
  if (*head_iter != S.front()) pair_count++;
  happiness += (S.cend() - head_iter) - 1;

  if (S.front() == S.back()) {
    // 端を含む連続部分が同じ方向を向いている場合、
    // すべての連続部分をその向きに揃えるように可能な限り操作を行う
    const size_t a = 2 * std::min(pair_count, K);  // パターンA
    happiness += a;
  } else {
    // 端を含む連続部分が異なる方向を向いている場合、
    // どちらかの向きに揃えるように可能な限り操作を行う
    const size_t n = pair_count - 1;
    const size_t a = 2 * std::min(n, K);  // パターンA
    const size_t b = n < K ? 1 : 0;  // パターンB（操作回数が余る場合のみ）
    happiness += a + b;
  }

  // 結果発表
  std::cout << happiness;

  return 0;
}