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()
  
  left_ac = [0]
  right_ac = [0]
  
  prev = ""
  for i in range(N):
      s = S[i]
      if s == "L":
          if i - 1 >= 0:
              if S[i - 1] == "L":
                  left_ac.append(left_ac[-1] + 1)
              else:
                  left_ac.append(left_ac[-1])
          else:
              left_ac.append(left_ac[-1])
          right_ac.append(right_ac[-1])
      else:
          if i + 1 < N:
              if S[i + 1] == "R":
                  right_ac.append(right_ac[-1] + 1)
              else:
                  right_ac.append(right_ac[-1])
          else:
              right_ac.append(right_ac[-1])
          left_ac.append(left_ac[-1])
  left_ac.pop(0)
  right_ac.pop(0)
  # print(left_ac)
  # print(right_ac)
  
  left = 0
  right = 0
  ans = right_ac[-1] + left_ac[-1]
  remain = K
  while left < N:
      s = S[left]
      while remain > 0 and right < N:
          if S[right] != s:
              if (right + 1 < N and S[right + 1] == s) or (
                  right == N - 1 and S[N - 1] != s
              ):
                  remain -= 1
          right += 1
  
      if s == "L":
          # print(s, right - left, left, right)
          tmp = right - left
          if right == N:
              tmp -= 1
          if right < N - 1:
              tmp += right_ac[-1] - right_ac[right + 1]
              tmp += left_ac[-1] - left_ac[right + 1]
          if left > 0:
              tmp += left_ac[left - 1] - left_ac[0]
              tmp += right_ac[left - 1] - right_ac[0]
          ans = max(ans, tmp)
      else:
          # print(s, right - left, left, right)
          tmp = right - left
          if right == N:
              tmp -= 1
          if right < N - 1:
              tmp += right_ac[-1] - right_ac[right + 1]
              tmp += left_ac[-1] - left_ac[right + 1]
          if left > 0:
              tmp += left_ac[left - 1] - left_ac[0]
              tmp += right_ac[left - 1] - right_ac[0]
          ans = max(ans, tmp)
  
      if right == left:
          right += 1
      if left + 1 < N and S[left + 1] != s:
          remain += 1
      left += 1
  print(ans)
  
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"}]