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 Rust (1.15.1) (judge verdict: Accepted)

#[allow(dead_code)]
fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}
#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}
#[allow(dead_code)]
fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}
#[allow(dead_code)]
fn yn(result: bool) {
    if result {
        println!("Yes");
    } else {
        println!("No");
    }
}

fn main() {
    let v = read_vec::<usize>();
    let n = v[0];
    let k = v[1];
    let s = read::<String>().chars().collect::<Vec<char>>();

    let mut sh = vec![false; n];
    for i in 0..n {
        if (i < n-1 && s[i] == 'R' && s[i] == s[i + 1])
        || (i > 0 && s[i] == 'L' && s[i] == s[i-1]) {
            sh[i] = true;
        }
    }

    //println!("{:?}", sh);

    let sh_count = sh.iter().filter(|&b| *b).count();
    if sh_count == n-1 {
        println!("{}", n-1);
        return;
    }

    let mut fushi_L = 0;
    let mut hashi_L = 0;
    let mut fushi_R = 0;
    let mut hashi_R = 0;
    for i in 0..n {
        if !sh[i] {
            if s[i] == 'L' {
                if i == 0 {
                    hashi_L = 1;
                }
                fushi_L += 1;
            } else if s[i] == 'R' {
                if i == n - 1 {
                    hashi_R = 1;
                }
                fushi_R += 1;
            }
        }
    }

    let mut sh_ans = sh_count;
    for _ in 0..k {
        if fushi_L >= 2 {
            sh_ans += 2;
            fushi_L -= 2;
        } else if fushi_R >= 2 {
            sh_ans += 2;
            fushi_R -= 2;
        } else if (hashi_R == 1 && hashi_L == 1)
        || (hashi_R == 0 && hashi_L == 0){
            sh_ans += 1;
            break;
        } else if fushi_L == 1 {
            if hashi_L == 0 {
                sh_ans += 1;
            }
            fushi_L -= 1;
        } else if fushi_R == 1 {
            if hashi_R == 0 {
                sh_ans += 1;
            }
            fushi_R -= 1;
            /*
        } else if (fushi_L == 1 && fushi_R == 0)
        || (fushi_R == 0 && fushi_R == 1) {
            sh_ans += 1;
            */
        } else {
            break;
        }
    }
    println!("{}", sh_ans);
}