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: #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  
  import sys
  import re
  
  N, K = tuple(map(int, sys.stdin.readline().rstrip().split()))
  s = sys.stdin.readline().rstrip()
  
  # print(N,K)
  # print(s)
  
  
  def rev_comp(s):
      tmp = s.translate(str.maketrans("LR", "RL"))
      return tmp[::-1]
  
  
  def score(s):
      sc = 0
      for i in range(len(s) - 1):
          sl = s[i : i + 2]
          if sl == "RR" or sl == "LL":
              sc += 1
      return sc
  
  
  lr = re.compile("LR.*RL")
  rl = re.compile("RL.*LR")
  lrl = re.compile("LRL")
  rlr = re.compile("RLR")
  
  r_l = re.compile("R+L+")
  l_r = re.compile("L+R+")
  ronly = re.compile("R+")
  lonly = re.compile("L+")
  
  flag = True
  
  while K > 0 and flag:
      flag = False
  
      m = re.search(lrl, s)
      while m and K > 0:
          start = m.start()
          end = m.end()
          s = s[:start] + "LLL" + s[end:]
  
          flag = True
          K = K - 1
          m = re.search(lrl, s)
  
      m = re.search(rlr, s)
      while m and K > 0:
          start = m.start()
          end = m.end()
          s = s[:start] + "RRR" + s[end:]
          flag = True
          K = K - 1
          m = re.search(rlr, s)
  
      m = re.search(lr, s)
      while m and K > 0:
          start = m.start()
          end = m.end()
          print(start, end)
  
          s = s[: start + 1] + rev_comp(s[start + 1 : end - 1]) + s[end - 1 :]
  
          flag = True
          K = K - 1
          m = re.search(lr, s)
  
      m = re.search(rl, s)
      while m and K > 0:
          start = m.start()
          end = m.end()
          print(start, end)
  
          s = s[: start + 1] + rev_comp(s[start + 1 : end - 1]) + s[end - 1 :]
  
          flag = True
          K = K - 1
          m = re.search(rl, s)
  
  
  flag = True
  while K > 0 and flag:
      flag = False
  
      m = re.search(r_l, s)
      while m and K > 0:
          end = re.search(ronly, s).end()
          s = rev_comp(s[:end]) + s[end:]
  
          flag = True
          K = K - 1
          m = re.search(r_l, s)
  
      m = re.search(l_r, s)
      while m and K > 0:
          end = re.search(lonly, s).end()
          s = rev_comp(s[:end]) + s[end:]
  
          flag = True
          K = K - 1
          m = re.search(r_l, s)
  
  
  # print(s)
  
  print(score(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"}]