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: Runtime Error)

fn read_line() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim_right().to_owned()
}

fn to_vec(s: String, offset: u64) -> Vec<u64> {
    s.split_whitespace()
        .map(|s| s.parse::<u64>().unwrap() - offset)
        .collect()
}

fn flip(mut facings: Vec<bool>, l: usize, r: usize) -> Vec<bool> {
    let len = r - l + 1;
    for i in 0..((len + 1) / 2) {
        let c = l + i;
        facings[c] = !facings[c];
        if c != r - i {
            facings.swap(c, r - i);
            facings[c] = !facings[c];
        }
    }
    facings
}

fn count_edge(facings: &Vec<bool>) -> u64 {
    let last = facings.len() - 1;
    (!facings[0] && !facings[1]) as u64 + (facings[last - 1] && facings[last]) as u64
}

fn count_mid(facings: Vec<bool>) -> u64 {
    facings
        .windows(3)
        .map(|w| if w[1] && w[0] {
            1
        } else if !w[1] && !w[2] {
            1
        } else {
            0
        })
        .sum()
}

fn find_happy_factor(facings: &Vec<bool>) -> Option<(usize, usize)> {
    let mut first: Option<(usize, bool)> = None;
    for (i, w) in facings.windows(2).enumerate() {
        // LR
        if w[0] && !w[1] {
            // LR -> RL
            if let Some((l, is_lr)) = first {
                if !is_lr {
                    return Some((l, i));
                }
            } else {
                first = Some((i + 1, true));
            }
        }
        // RL
        else if !w[0] == w[1] {
            // RL -> LR
            if let Some((l, is_lr)) = first {
                if is_lr {
                    return Some((l, i));
                }
            } else {
                first = Some((i + 1, false));
            }
        }
    }
    None
}

fn main() {
    let v = to_vec(read_line(), 0);
    let (_, k) = (v[0], v[1]);
    let mut facings: Vec<bool> = read_line().chars().map(|c| c == 'L').collect();

    for _ in 0..k {
        if let Some((l, r)) = find_happy_factor(&facings) {
            facings = flip(facings, l, r);
        } else {
            break;
        }
    }

    println!("{}", count_edge(&facings) + count_mid(facings));
}