Problem: 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?

Submission attempts (in order):
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

if left_ac[-1] == 0 and right_ac[-1] == 0:
    if K==0:
        print(0)
        exit()
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]
            tmp += left_ac[-1] - left_ac[right]
        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]
            tmp += left_ac[-1] - left_ac[right]
        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)


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(min(N-1, right_ac[-1] + left_ac[-1] + 2 * K))


Verdicts: Wrong Answer

Accepted