output_description: Print the maximum possible number of happy people after at most K operations.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      S
attempt: def d(s, type):
      first_index = None
      last_index = None
      for i in range(0, n - 1):
          if first_index == None:
              if s[i] != type:
                  first_index = i
                  if s[len(s) - 1] != type:
                      last_index = len(s) - 1
                      break
          if s[i] != type and s[i + 1] == type:
              last_index = i
      if last_index == None and first_index != None:
          last_index = len(s) - 1
      return first_index, last_index
  
  
  def find(n, k, s):
      f1, l1 = d(s, "R")
      f2, l2 = d(s, "L")
  
      valid1 = f1 is not None and l1 is not None
      valid2 = f2 is not None and l2 is not None
  
      if not valid2:
          return f1, l1
  
      if not valid1:
          return f2, l2
  
      if (l2 - f2) < (l1 - f1):
          return f2, l2
      else:
          return f1, l1
  
  
  def o(s):
      if s == "L":
          return "R"
      else:
          return "L"
  
  
  def turn(list, first_index, last_index):
      for i in range(last_index - first_index):
          l = first_index + i
          r = last_index - i
          if l > r:
              break
          org_l = list[l]
          org_r = list[r]
          list[l] = o(org_r)
          list[r] = o(org_l)
  
  
  def calc(list):
      r = 0
      for i in range(len(list)):
          if list[i] == "R" and i < len(list) - 1:
              if list[i] == list[i + 1]:
                  r += 1
          if list[i] == "L" and i >= 1:
              if list[i] == list[i - 1]:
                  r += 1
      return r
  
  
  n, k = list(map(int, input().split()))
  s = list(input())
  
  for _ in range(k):
      first_index, last_index = find(n, k, s)
      turn(s, first_index, last_index)
  
  print(calc(s))
  
problem_description: 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?
samples: [{"input": "6 1\n    LRLRRL", "output": "3\n    \n\nIf we choose (l, r) = (2, 5), we have `LLLRLL`, where the 2-nd, 3-rd, and 6-th\npersons from the west are happy.\n\n* * *"}, {"input": "13 3\n    LRRLRLRRLRLLR", "output": "9\n    \n\n* * *"}, {"input": "10 1\n    LLLLLRRRRR", "output": "9\n    \n\n* * *"}, {"input": "9 2\n    RRRLRLRLL", "output": "7"}]