#if 1
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>
#include <functional>
#include <set>
#include <map>
#include <numeric>
#include <cassert>
#include <iomanip>
#include <queue>
#include <chrono>
#define _SCL_SECURE_NO_WARNINGS
#include "boost/multiprecision/cpp_int.hpp"

#pragma warning (disable:4244)


using namespace std;

using int128 = boost::multiprecision::int128_t;
#if 0
#define int boost::multiprecision::int128_t
#else
#define int long long
#endif
#if 1
constexpr long long MOD = 1000000007LL;
#else
constexpr long long MOD = 998244353LL;
#endif
constexpr long long INF = 1145141919810893LL;

//
#if 1


struct Val {
	int x = 0;
	int r = 0;
};

int count111 = 0;


//ダイクストラ法を使うときはTとしてこれを継承したものを使う
struct Dijk {
	static constexpr auto MINVAL = std::numeric_limits<int>::min();
	int dis = MINVAL;
};
struct Bellman {
	int dis = std::numeric_limits<int>::max() / 2;				//緩和の初期値(何かが足されてもオーバーフローしないように)
	int predecessor = -1;										//直前の頂点？
};
struct Edge {
	int next;
	int w = 1;
};
template<class T>
struct Vertex {
	std::vector<Edge>edges;
	T val;
};
template<class T>
struct Graph {
	std::vector<Vertex<T>> vertex;
public:
	Graph(size_t nVertex = 0) :vertex(nVertex) {
	}
	void setArray(int u, int v, int w = 1) {
		vertex[u].edges.push_back(Edge{ v ,w });
	}
	void setConnect(int u, int v, int w = 1) {
		setArray(u, v, w);
		setArray(v, u, w);
	}
	T& val(int u) {
		return vertex[u].val;
	}
	void dfsImpl(int pos, int prev, std::function<bool(int now, int next, int w)> func) {
		count111 += val(pos).x;
		val(pos).r = count111;
		for (auto& e : vertex[pos].edges) {
			if (e.next == prev) continue;
			if (func(pos, e.next, e.w)) {
				dfsImpl(e.next, pos, func);
			}
			//ここに追加する場合も
		}
		count111 -= vertex[pos].val.x;
	}
	void dfsCustom(int pos, int prev);
	//深さ優先探索
	void dfs(int pos, std::function<bool(int now, int next, int w)> func) {
		dfsImpl(pos, -1, func);
	}
	//幅優先探索
	void bfs(int pos, std::function<bool(int now, int next, int w)> func) {
		std::unordered_set<int> set;
		set.insert(pos);
		while (!set.empty()) {
			std::unordered_set<int> setNew;
			for (auto& one : set) {
				for (auto& e : vertex[one].edges) {
					if (func(one, e.next, e.w)) {
						setNew.insert(e.next);
					}
				}
			}
			set = setNew;
		}
	}
	//posStartを始点とするダイクストラ法
	//ループがあるグラフでの動作は未検証		O(V^2)で、工夫してO((E+V)logV)らしいができてない
	//木の場合はO(V)、動作確認済
	void dijkstra(int posStart) {
		val(posStart).dijk = 0;
		//
		bfs(posStart, [&](int now, int next, int w) {
			if (val(next).dijk == Dijk::MINVAL || val(next).dijk > val(now).dijk + w) {
				val(next).dijk = val(now).dijk + w;
				return true;
			}
			return false;
			});
	}
	//posStartを始点とするベルマン-フォード法
	//負の閉路に対応するがO(VE)
	//負の経路を検出したらfalseを返す(この場合、結果が正しいとは限らない)
	//posEndを指定した場合、posStart -> posEnd　の最短経路間でのみ負経路検出を行う、-1なら全体
	bool bellmanFord(int posStart, int posEnd = -1) {
		// この実装では、グラフを頂点のリストと辺のリストで表す。
		// そして、各頂点の distance と predecessor 属性が
		// 最短経路を格納するよう変更していく。
		// Step 1: グラフの初期化
		val(posStart).dis = 0;
		// Step 2: 辺の緩和を反復
		for (int jj = 0; jj < vertex.size() * 2; ++jj) {
			for (int i = 0; i < vertex.size(); ++i) {
				for (auto& edge : vertex[i].edges) {
					auto tmp = val(i).dis + edge.w;
					if (val(edge.next).dis > tmp) {
						val(edge.next).dis = tmp;
						val(edge.next).predecessor = i;
					}
				}
			}
		}
		// Step 3: 負の重みの閉路がないかチェック
		if (0 > posEnd) {
			for (int i = 0; i < vertex.size(); ++i) {
				for (auto& edge : vertex[i].edges) {
					if (val(edge.next).dis > val(i).dis + edge.w) {
						return false;
					}
				}
			}
		}
		else {
			assert(false);	//なんかうまくできてないっぽい
			int v = posEnd;
			do {
				auto prev = val(v).predecessor;
				assert(prev != -1);
				int weight = std::numeric_limits<int>::min();
				for (auto& edge : vertex[prev].edges) {
					if (edge.next == v) {
						weight = edge.w;
						break;
					}
				}
				assert(weight != std::numeric_limits<int>::min());
				if (val(v).dis > val(prev).dis + weight) {
					return false;
				}
				v = prev;
			} while (v != posStart);
		}
		return true;
	}
	pair<int, int> radiusImpl(int pos) {
		int farestID = -1;
		int far = -1;
		val(pos) = 0;
		//dfsで正しい？？
		dfs(pos, [&](int now, int next, int w) {
			val(next) = 1 + val(now);
			if (val(next) > far) {
				far = val(next);
				farestID = next;
			}
			});
		return { farestID, far };
	}
	int radius() {
		if (vertex.size() <= 1)return 0;
		auto res = radiusImpl(0);
		res = radiusImpl(res.first);
		return res.second;
	}
};
#endif

//////////////////////////////////
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int sign(int x) {
	if (x > 0)return 1;
	if (x < 0)return -1;
	return 0;
}
//マイナスでも動作するmod(いちいち手で書くとunsignedの引き算オーバーフローで死にやすい)
int mod(int n, int m = MOD) {
	assert(0 < m);	//さすがに割る数は正でないといけない
	return (n % m + m) % m;
}

//約数
std::vector<int> divisor(int n) {
	std::vector<int> ret;
	for (int i = 1; i * i <= n; ++i) {
		if (n % i == 0) {
			ret.push_back(i);
			if (i * i != n) {
				ret.push_back(n / i);
			}
		}
	}
	return ret;
}

bool isPrime(int n) {
	if (n <= 1)return false;
	if (n == 2)return true;
	if (n % 2 == 0)return false;
	for (int i = 3; i * i <= n; i += 2) {
		if (n % i == 0)return false;
	}
	return true;
}

////////////////////////
#if 1
//二項係数、int128は使わなく64で十分
class Combination {
	std::vector<long long>fac, finv, inv;
	long long M;		//剰余
public:
	Combination(long long N, long long M_ = MOD)
		:fac(N + 1), finv(N + 1), inv(N + 1), M(M_) {
		fac[0] = fac[1] = 1;
		finv[0] = finv[1] = 1;
		inv[1] = 1;
		for (long long i = 2; i < N + 1; i++) {
			fac[i] = fac[i - 1] * i % M;
			inv[i] = M - inv[M % i] * (M / i) % M;
			finv[i] = finv[i - 1] * inv[i] % M;
		}
	}
	long long get(long long n, long long k) {
		if (n < k) return 0;
		if (n < 0 || k < 0) return 0;
		return fac[n] * (finv[k] * finv[n - k] % M) % M;
	}
};

#endif
#if 1

//Mを法とする逆数、計算量:？
int modInv(int a, int M = MOD) {
	int b = M, u = 1, v = 0;
	while (b) {
		int t = a / b;
		a -= t * b; swap(a, b);
		u -= t * v; swap(u, v);
	}
	u %= M;
	if (u < 0) u += M;
	return u;
}

template <class T>
void modify(T& n, T mod = MOD) {
	if (n < 0) {
		n %= mod;
		n += mod;
	}
	n %= mod;
}

#endif

//文字列の置き換え(遅い？)
int replace(std::string* str, const std::string& old_, const std::string& new_) {
	std::string& String1 = *str;
	//String1.reserve(str->size() * new_.size() / old_.size() + 1);
	std::string::size_type  Pos(String1.find(old_));
	int result = 0;
	while (Pos != std::string::npos) {
		result++;
		String1.replace(Pos, old_.length(), new_);
		Pos = String1.find(old_, Pos + new_.length());
	}
	return result;
}

#define ALL(t) t.begin(), t.end()


//LIS(最長増加部分列)
//eq = falseで狭義増加(1,3,7,9...)
//eq = trueで広義増加(1,1,3,7,7,7,7,9...)
std::vector<int> lis(const std::vector<int>& ary, bool eq = false) {
	std::vector<int>dp(ary.size());
	constexpr int intMax = std::numeric_limits<int>::max();
	fill(ALL(dp), intMax);
	for (int i = 0; i < ary.size(); ++i) {
		auto itr = std::lower_bound(ALL(dp), ary[i] + (eq ? 1 : 0));
		*itr = ary[i];
	}
	auto itr = std::lower_bound(ALL(dp), intMax);
	dp.resize(itr - dp.begin());
	return dp;
}

//座標圧縮:O(NlogN)
struct Compressor {
	std::set<int> buf;
	std::unordered_map<int, int>res;
public:
	template <class... Args>
	void insert(Args... args) {
		buf.insert(args...);
	}
	void calc() {
		res.clear();
		int i = 0;
		for (auto& one : buf) {
			res[one] = i;
			++i;
		}
	}
	int get(int n) const {
		return res.at(n);
	}
	std::vector<int> get(const std::vector<int>& v) const {
		std::vector<int> res(v.size());
		for (int i = 0; i < v.size(); ++i) {
			res[i] = get(v[i]);
		}
		return res;
	}
};

//MODで割ったあまりの演算
struct Rational {
	int r;
	Rational(int rr) :r(rr) {
	}
	Rational() = default;		//vectorに入れたりするときに必要
	operator int() {
		return r;
	}
	Rational operator+(const Rational& other)const {
		Rational res(0);
		res.r = r + other.r;
		modify(res.r);
		return res;
	}
	Rational operator-(const Rational& other)const {
		Rational res(0);
		res.r = r - other.r;
		modify(res.r);
		return res;
	}
	Rational operator*(const Rational& other) const {
		Rational res(0);
		res.r = r * other.r;
		modify(res.r);
		return res;
	}
	Rational operator/(const Rational& other)const {
		Rational res(0), res1(0);
		res = *this;
		res1.r = modInv(other.r);
		res = (*this) * res1;
		modify(res.r);
		return res;
	}
	void operator+=(const Rational& other) {
		*this = *this + other;
	}
	void operator-=(const Rational& other) {
		*this = *this - other;
	}
	void operator*=(const Rational& other) {
		*this = *this * other;
	}
	void operator/=(const Rational& other) {
		*this = *this / other;
	}
};

Rational pow(Rational r, int N) {
	if (N == 0)return Rational(1);
	if (N % 2 == 1)return r * pow(r, N - 1);
	Rational tmp = pow(r, N / 2);
	return tmp * tmp;
}
Rational operator"" _r(unsigned long long val) {
	return Rational(val);
}

/////////////////////

//KMP文字列検索
//計算量:O(|S|+|W|)
//ボイヤームーアは実務では良くても競プロでは使ってはいけない(最悪ケースで二乗オーダ)
struct KMP {
	std::string W;	//検索する文字列
	std::vector<int> T;	//テーブル
public:
	//計算量:O(|W|)
	KMP(const std::string& W_) :W(W_) {
		T.resize(W.size() + 1);
		int i = 2;		//T の中で現在計算している位置
		int j = 0;		//現在見ているサブ文字列の次の文字のインデックス。0から始まる
		//先頭ふたつの値は固定。ただしアルゴリズムの実装によっては具体的値は異なる
		T[0] = -1;
		if (2 <= W.size()) {
			T[1] = 0;
		}
		while (i <= W.size()) {
			if (W[i - 1] == W[j]) {
				T[i] = j + 1;
				i = i + 1;
				j = j + 1;
			}
			else if (j > 0) {
				j = T[j];
			}
			else {
				T[i] = 0;
				i = i + 1;
			}
		}
	}
	//return: W が見つかった際の S 内の位置を全列挙(先端が0番目)
	//全列挙でも一個探す場合と計算量的に変わらない
	//(むしろ一個探す実装を繰り返して全列挙するとTLEする)
	//Sを変えて複数回呼べる
	//計算量:O(|S|)
	std::vector<int> searchAll(const std::string& S)const {
		std::vector<int>res;
		//S 内の現在照合中の開始位置
		int m = 0;
		//W 内の現在位置
		int i = 0;
		while (m + i < S.size()) {
			if (W[i] == S[m + i]) {
				++i;
				if (i == W.size()) {
					res.push_back(m);
				}
				else {
					continue;
				}
			}
			m = m + i - T[i];
			if (i > 0) {
				i = T[i];
			}
		}
		return res;
	}
};

//累積和
std::vector<int> MAKESUM(const std::vector<int>& A) {
	std::vector<int>res(A.size() + 1);
	res[0] = 0;
	for (int i = 1; i < A.size() + 1; ++i) {
		res[i] = res[i - 1] + A[i - 1];
	}
	return res;
}

//セグメント木
struct SegmentTree {
	std::vector<int>val;
	size_t size;
public:
	SegmentTree(size_t sz) {
		//2の累乗でないといけない
		assert((sz & (sz - 1)) == 0);
		//
		val.resize(sz * 2 - 1);
		size = sz;
	}
	void fill(int v) {
		std::fill(val.begin(), val.end(), v);
	}
	//TODO 全部に初期値を入れてからやるばあいはまとめて更新するとO(N)でできる
	//	setをN回呼ぶとNlogNかかる

	//群の演算
	static int operate(int a, int b) {
		return a + b;
	}
	//群の単位元
	static int unit() {
		return 0;
	}
	void set(int idx, int v) {
		assert(0 <= idx && idx < size);
		int offset = size;
		val[offset - 1 + idx] = v;
		int segSize = 1;
		while (offset > 1) {
			val[offset / 2 - 1 + idx / segSize / 2]
				= SegmentTree::operate(val[offset - 1 + idx / segSize / 2 * 2 + 0], val[offset - 1 + idx / segSize / 2 * 2 + 1]);
			offset /= 2;
			segSize *= 2;
		}
	}
	int query(int a, int b, int k, int l, int r) {
		// https://www.slideshare.net/iwiwi/ss-3578491 を参考にした
		if (r <= a || b <= l) return unit();
		// 交差しない？
		if (a <= l && r <= b) return val[k];
		// 完全に含む？
		else {
			int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
			int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
			return operate(vl, vr);
		}

	}
	//[a,b)のoperateの結果を得る
	//max,gcdなど逆演算ができないものを考慮すると[0,a)が取得できるだけでは不十分
	int get(int a, int b) {
		return query(a, b, 0, 0, size);
	}
};


int TLE() {
	volatile int res = 0;
	for (int i = 0; i < INF; ++i) {
		res += i;
	}
	return res;
}
void MLE() {
	//なぜかvolatile auto *p =new char[N]ではMLEにならない(多分gcc O2の最適化)
	constexpr int N = 1024 * 1024 * 1024;
	std::vector<char>v(N);
	v.back() = 0;		//最適化防止？
}
void OLE() {
	for (int i = 0; i < INF; ++i) {
		//endlを出力するとWAになる？
		//数字を出力した方がいい？
		//ストリーム版だとTLEになる？
		printf("8127\n");
	}
}
void RE() {
	throw 1000000007;
}


void chmax(int& val, int max) {
	val = std::max({ val,max });
}

void chmin(int& val, int min) {
	val = std::min({ val,min });
}

template <class T>
void PRINT(const T& con) {
	cout << "(";
	for (auto& one : con) {
		cout << one << ",";
	}
	cout << ")" << endl;
}

//a以上の整数でmで割ってk余る最小の数
//(b以下の最大の数が欲しい場合は適宜帰着して使う)
int minimumMod(int a, int m, int k) {
	int res = (a - k) / m * m + k;
	if (a <= res - m)return res - m;
	if (a <= res)return res;
	return res + m;
}


constexpr double pi = 3.141592653589793238462;
//////////////////

#define LOADVEC(type,name,N) std::vector<type>name(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
	cin >> name[nnn]; \
}

#define LOADVEC2(type,name0,name1,N) std::vector<type>name0(N),name1(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
	cin >> name0[nnn];cin >> name1[nnn]; \
}

#define LOADVEC3(type,name0,name1,name2,N) std::vector<type>name0(N),name1(N),name2(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
	cin >> name0[nnn];cin >> name1[nnn];cin >> name2[nnn]; \
}

#define LOAD(type,name) type name; \
cin >> name;

void proc();

signed main() {
	ios::sync_with_stdio(false);
	std::cout << std::setprecision(30);
	proc();
	return 0;
}

/*
--------------------------------------------------------
--------------------------------------------------------
---------------    template      ----------------------
--------------------------------------------------------
--------------------------------------------------------
*/



#if 0

struct S {
	int dis = -1;
};

template<class T>
void Graph<T>::dfsCustom(int pos, int prev) {
	int nEdge = 0;
	for (auto& e : vertex[pos].edges) {
		const int next = e.next;
		if (next == prev) continue;
		if (val(next).dis == -1) {
			val(next).dis = val(pos).dis + 1;
			dfsCustom(next, pos);
			++nEdge;
		}
		else if (val(next).dis < val(pos).dis) {
			//ここに来たなら木ではない(後退辺の処理)
			assert(false);
		}
	}
	//
	int rat = K - 1;
	if (val(pos).dis == 0) {
		for (int i = 0; i < nEdge; ++i) {
			res *= rat;
			modify(res);
			--rat;
		}
	}
	else {
		--rat;
		for (int i = 0; i < nEdge; ++i) {
			res *= rat;
			modify(res);
			--rat;
		}
	}
}

#endif



void proc() {
	LOAD(int, N);
	LOAD(int, K);
	LOAD(std::string, S);
	S = std::string({ 'R' }) + S + std::string({ 'L' });
	int ok = 0;
	for (int i = 1; i < N + 1; ++i) {
		if (S[i] == 'L') {
			if (S[i - 1] == S[i])++ok;
		}
		else {
			if (S[i + 1] == S[i])++ok;
		}
	}
	ok += 2 * K;
	chmin(ok, N - 1);
	cout << ok << endl;
}

#endif




Measured memory_bytes: 512