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 Ruby (2.3.3) (judge verdict: Accepted)

require 'pp'

def gets; ARGF.gets; end

class Solver

  def main
    n, k = gets.chomp.split.map(&:to_i)

    last_c = 'Z'
    num = 0
    nums = []
    gets.chomp.each_char do |c|
      if last_c != c
        nums << num
        num = 1
      else
        num += 1
      end
      last_c = c
    end
    nums << num
    nums << 0
    # puts nums

    # 持ち点計算
    sum = 0
    nums.each do |i|
      if 1 < i
        sum += i - 1
      end
    end
    # puts sum

    # (n * 2) + 1 長さ の合計を尺取で
    # そのとき、2以上のを取り込んだら、rest を引いていく
    # 2以上のを排出したら rest に加算しておく
    rest = sum

    l = 0
    r = [k * 2, nums.length - 1].min
    cur = 0
    max_p = 0
    l.upto(r) do |i|
      if 1 < nums[i]
        rest -= nums[i] - 1
      end
      cur += nums[i]
    end
    if max_p < (cur - 1) + rest
      max_p = (cur - 1) + rest
    end

    t = nums.length - (k * 2 + 1)
    if t <= 0
      puts max_p
      return
    end

    t.times do
      if 1 < nums[l]
        rest += nums[l] - 1
      end
      cur -= nums[l]
      l += 1

      r += 1
      if 1 < nums[r]
        rest -= nums[r] - 1
      end
      cur += nums[r]

      if max_p < (cur - 1) + rest
        max_p = (cur - 1) + rest
      end
    end

    puts max_p
  end
end

if __FILE__ == $0
  Solver.new.main
end