Problem:
Score : 400 points

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

Constraints

N is an integer satisfying 1 \leq N \leq 10^5.

K is an integer satisfying 1 \leq K \leq 10^5.

|S| = N

Each character of S is L or R.

Input

Input is given from Standard Input in the following format:

N K
S

Output

Print the maximum possible number of happy people after at most K operations.

Sample Input 1

6 1
LRLRRL

Sample Output 1

3

If we choose (l, r) = (2, 5), we have LLLRLL, where the 2-nd, 3-rd, and 6-th persons from the west are happy.

Sample Input 2

13 3
LRRLRLRRLRLLR

Sample Output 2

9

Sample Input 3

10 1
LLLLLRRRRR

Sample Output 3

9

Sample Input 4

9 2
RRRLRLRLL

Sample Output 4

7

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{
    partial class Program
    {
		static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
		static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
		
        public static int[] ZAlgotithm(string s)
        {
            var len = s.Length;

            var a = new int[len];
            a[0] = len;
            var i = 1;
            var j = 0;
            while (i < len)
            {
                while (i + j < len && s[j] == s[i + j]) j++;
                a[i] = j;

                if (j == 0)
                {
                    i++;
                    continue;
                }

                var k = 1;
                while (i + k < len && k + a[k] < j)
                {
                    a[i + k] = a[k];
                    k++;
                }
                i += k;
                j -= k;
            }

            return a;
        }
        public class MaxHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;

            public MaxHeap() : this(0) { }
            public MaxHeap(int capacity, Comparison<T> comp=null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }
            
            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }

            
            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c > 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if(j+1 < _list.Count && _comp.Compare(_list[j], _list[j+1]) < 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) < 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
        public class PriorityQueue<T> where T : IComparable
        {
            private IComparer<T> _comparer = null;
            private int _type = 0;

            private T[] _heap;
            private int _sz = 0;

            private int _count = 0;

            /// <summary>
            /// Priority Queue with custom comparer
            /// </summary>
            public PriorityQueue(int maxSize, IComparer<T> comparer)
            {
                _heap = new T[maxSize];
                _comparer = comparer;
            }

            /// <summary>
            /// Priority queue
            /// </summary>
            /// <param name="maxSize">max size</param>
            /// <param name="type">0: asc, 1:desc</param>
            public PriorityQueue(int maxSize, int type = 0)
            {
                _heap = new T[maxSize];
                _type = type;
            }

            private int Compare(T x, T y)
            {
                if (_comparer != null) return _comparer.Compare(x, y);
                return _type == 0 ? x.CompareTo(y) : y.CompareTo(x);
            }

            public void Push(T x)
            {
                _count++;

                //node number
                var i = _sz++;

                while (i > 0)
                {
                    //parent node number
                    var p = (i - 1) / 2;

                    if (Compare(_heap[p], x) <= 0) break;

                    _heap[i] = _heap[p];
                    i = p;
                }

                _heap[i] = x;
            }

            public T Pop()
            {
                _count--;

                T ret = _heap[0];
                T x = _heap[--_sz];

                int i = 0;
                while (i * 2 + 1 < _sz)
                {
                    //children
                    int a = i * 2 + 1;
                    int b = i * 2 + 2;

                    if (b < _sz && Compare(_heap[b], _heap[a]) < 0) a = b;

                    if (Compare(_heap[a], x) >= 0) break;

                    _heap[i] = _heap[a];
                    i = a;
                }

                _heap[i] = x;

                return ret;
            }

            public int Count()
            {
                return _count;
            }

            public T Peek()
            {
                return _heap[0];
            }

            public bool Contains(T x)
            {
                for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true;
                return false;
            }

            public void Clear()
            {
                while (this.Count() > 0) this.Pop();
            }

            public IEnumerator<T> GetEnumerator()
            {
                var ret = new List<T>();

                while (this.Count() > 0)
                {
                    ret.Add(this.Pop());
                }

                foreach (var r in ret)
                {
                    this.Push(r);
                    yield return r;
                }
            }

            public T[] ToArray()
            {
                T[] array = new T[_sz];
                int i = 0;

                foreach (var r in this)
                {
                    array[i++] = r;
                }

                return array;
            }
        }
        static void Main(string[] args)
        {
			//↓

            var nk = ReadIntArray();
            var n = nk[0];
            var k = nk[1];
            var s = Console.ReadLine();


            var h = 0;
            var prev = ' ';
            var flip = 0;
            for (int i = 0; i < n; i++)
            {
                var c = s[i];
                if (prev == c)
                {
                    h++;
                }
                else
                {
                    flip++;
                    prev = c;
                }
            }

            var fc = Math.Min(k, (flip - ((n%2==0)?2:1)) / 2);
            var rest = Math.Max(k - fc, 0);

            Console.WriteLine(h + fc * 2 + ((rest > 0 && flip % 2 == 0) ? 1 : 0));


			//↑
        }

	}
}