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: N, K = map(int, input().split())
  S = input()
  
  largest = 0
  largest_left_index = -1
  
  sum_list = list()
  
  count = 0
  for i in range(N):
      if S[i] == "L":
          if count <= 0:
              count = count - 1
          else:
              sum_list.append(count)
              count = -1
      elif S[i] == "R":
          if count >= 0:
              count = count + 1
          else:
              sum_list.append(-count)
              count = 1
  else:
      sum_list.append(count) if count > 0 else sum_list.append(-count)
  
  length = len(sum_list)
  current_max = 0
  current_max_index = 0
  for j in range(length):
      current_sum = sum_list[j]
      if j < length - 1:
          current_sum = current_sum + sum_list[j + 1]
      if j < length - 2:
          current_sum = current_sum + sum_list[j + 2]
  
      if current_sum > current_max:
          current_max = current_sum
          current_max_index = j
  
  if current_max_index < length - 2:
      sum_list.pop(current_max_index + 2)
  if current_max_index < length - 1:
      sum_list.pop(current_max_index + 1)
  sum_list.pop(current_max_index)
  sum_list.insert(current_max_index, current_max)
  
  for i in range(K - 1):
      left = sum_list[current_max_index]
      if current_max_index > 1:
          left = left + sum_list[current_max_index - 1]
      if current_max_index > 2:
          left = left + sum_list[current_max_index - 2]
  
      right = sum_list[current_max_index]
      if current_max_index < len(sum_list) - 1:
          right = right + sum_list[current_max_index + 1]
      if current_max_index < len(sum_list) - 2:
          right = right + sum_list[current_max_index + 2]
  
      if left >= right:
          sum_list.pop(current_max_index)
          sum_list.insert(current_max_index, left)
          if current_max_index > 1:
              sum_list.pop(current_max_index - 1)
          if current_max_index > 2:
              sum_list.pop(current_max_index - 2)
      else:
          length = len(sum_list)
          if current_max_index < length - 2:
              sum_list.pop(current_max_index + 2)
          if current_max_index < length - 1:
              sum_list.pop(current_max_index + 1)
          sum_list.pop(current_max_index)
          sum_list.insert(current_max_index, right)
  
  res = 0
  for i in range(len(sum_list)):
      res = res + sum_list[i] - 1
  
  print(res)
  
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"}]