solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
class cmp {
int n;
public:
cmp(int p) : n(p) {}
bool operator()(pair<int, int> &a, pair<int, int> &b) {
int x = a.second - a.first + 1;
int y = b.second - b.first + 1;
if (a.first == 0) return false;
if (b.first == 0) return true;
if (a.second == n) return false;
if (b.second == n) return true;
return x <= y;
}
};
bool comp(pair<int, int> &a, pair<int, int> &b) {
return a.second - a.first < b.second - b.first;
}
int get(string &w) {
int cnt = 0;
for (int i = 0; i < (int)w.size(); i++) {
if (w[i] == 'W') {
if (i != 0 && w[i - 1] != 'L')
cnt += 2;
else
cnt++;
}
}
return cnt;
}
int solve(string &s, int k) {
int n = s.size();
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') cnt++;
}
if (k >= cnt) {
return 2 * (n - 1) + 1;
}
vector<pair<int, int>> v;
int ind = 0;
while (ind < n && s[ind] == 'L') ind++;
int l = ind - 1;
int m = n - 1;
while (m >= 0 && s[m] == 'L') {
m--;
}
while (ind <= m) {
if (s[ind] == 'W')
ind++;
else {
int a = ind;
int b = ind;
while (b < n && s[b] == 'L') b++;
v.push_back({a, b - 1});
ind = b;
}
}
sort(v.begin(), v.end(), comp);
for (int i = 0; i < (int)v.size() && k > 0; i++) {
int p = v[i].first;
int q = v[i].second;
if (p == 0) {
for (; q >= p && k > 0; q--) {
s[q] = 'W';
k--;
}
} else {
for (; p <= v[i].second && k > 0; p++) {
s[p] = 'W';
k--;
}
}
}
m++;
while (m < n && k > 0) {
s[m] = 'W';
m++;
k--;
}
while (l >= 0 && k > 0) {
s[l] = 'W';
l--;
k--;
}
return get(s);
}
int main() {
int tc;
cin >> tc;
while (tc--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
cout << solve(s, k) << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 1000000007;
const long long INF = mod * mod;
const long double eps = 1e-12;
const long double pi = acosl(-1.0);
long long mod_pow(long long x, long long n, long long m = mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % m;
x = x * x % m;
n >>= 1;
}
return res;
}
struct modint {
long long n;
modint() : n(0) { ; }
modint(long long m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint& a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint& a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, long long n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 17;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
void solve() {
int n;
cin >> n;
int k;
cin >> k;
string s;
cin >> s;
bool exi = false;
for (int i = 0; i < s.size(); i++)
if (s[i] == 'W') exi = true;
if (!exi) {
cout << max(0, 2 * k - 1) << "\n";
return;
}
int rs = 0;
vector<int> vs;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W') continue;
int le = i;
while (i + 1 < s.size() && s[i + 1] == 'L') i++;
if (le == 0 || i == n - 1) {
rs += i - le + 1;
} else {
vs.push_back(i - le + 1);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
ans++;
if (i > 0 && s[i - 1] == 'W') ans++;
}
}
sort((vs).begin(), (vs).end());
for (int i = 0; i < vs.size(); i++) {
if (k >= vs[i]) {
ans += 2 * vs[i] + 1;
k -= vs[i];
} else {
ans += 2 * k;
k = 0;
}
}
int mi = min(k, rs);
ans += 2 * mi;
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, k = [int(i) for i in input().split()]
lst = sorted(map(len,input().strip('L').split('W')))
m = len(lst) -1 + k
while lst and lst[0] <= k:
k -= lst.pop(0)
print((2 * min(n, m) - len(lst) or 1) - 1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v;
int w = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W') {
w++;
}
}
if (w == 0) {
if (k == 0) {
cout << "0" << endl;
} else {
cout << 2 * k - 1 << endl;
}
continue;
}
w += k;
if (w >= n) {
cout << 2 * n - 1 << endl;
continue;
} else {
int l = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'L') {
l++;
} else {
v.push_back(l);
l = 0;
}
}
if (l != 0) {
v.push_back(l);
}
if (s[0] == 'L') {
v.erase(v.begin());
}
if (s[n - 1] == 'L') {
v.erase(v.begin() + v.size() - 1);
}
sort(v.begin(), v.end());
int i;
int sp = 0;
for (i = 0; i < v.size(); i++) {
if (sp + v[i] > k) break;
sp += v[i];
}
int w1 = v.size() - i;
cout << 2 * w - w1 - 1 << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.second == b.second) {
return a.first < b.first;
}
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t-- > 0) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long i = 0, p = n - 1;
while (i < n && s[i] == 'L') {
i++;
}
while (p >= 0 && s[p] == 'L') {
p--;
}
long long r = i - 1;
vector<pair<long long, long long>> v;
while (i <= p) {
if (s[i] == 'W') {
while (s[i] == 'W' && i <= p) {
i++;
}
}
if (s[i] == 'L') {
long long pos = i;
while (s[i] == 'L' && i <= p) {
i++;
}
v.push_back({pos, i - pos});
}
}
sort(v.begin(), v.end(), cmp);
for (long long i = 0; i < v.size(); i++) {
long long idx = v[i].first;
long long len = v[i].second;
for (long long j = idx; j < (idx + len); j++) {
if (k > 0) {
s[j] = 'W';
k--;
}
}
}
if (k > 0) {
p++;
while (p < n && k > 0) {
s[p] = 'W';
p++;
k--;
}
}
if (k > 0) {
while (r >= 0 && k > 0) {
s[r] = 'W';
r--;
k--;
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if ((i - 1) >= 0 && s[i] == 'W' && s[i - 1] == 'W') {
ans += 2;
} else if (s[i] == 'W') {
ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
import sys
t= int(input())
for _ in range(t):
[n, k]=list(map(int,input().split()))
temp=0
for line in sys.stdin:
s=line
break
prev='L'
current='L'
lsum=0
tempsum=0
losses=[]
startind=0
endind=n-1
while startind!=n and s[startind]=='L':
startind+=1
while endind!=-1 and s[endind]=='L':
endind-=1
for i in range(startind, endind+1):
current=s[i]
if current=='L' and prev=='L':
lsum+=1
tempsum+=1
elif current=='L' and prev=='W':
tempsum=1
lsum+=1
elif current=='W' and prev=='L':
if i!=startind:
losses.append(tempsum)
prev=current
losses.sort()
startloss=startind
endloss= n-1-endind
lsum+=(startloss+endloss)
starts=len(losses)+1
losses.append(startloss)
losses.append(endloss)
if startind==n:
print(max(2*k-1,k))
else:
ind = 0
remk=k
while ind < len(losses) and remk>0:
if remk>= losses[ind]:
remk -= losses[ind]
lsum-=losses[ind]
if ind< len(losses)-2:
starts-=1
else:
lsum-=remk
break
ind+=1
# print(lsum)
# print(n)
# print(endloss)
# print(startloss)
# print(starts)
print((n-lsum)*2-starts) | 8 | PYTHON3 |
import sys
import math as m
def fi():
return sys.stdin.readline()
if __name__ == '__main__':
for _ in range (int(fi())):
n,k = map(int, fi().split())
s = list(fi())
s.pop()
p = 0
q = 0
flag = 0
ans = 0
prev = 'L'
l = []
c = 0
for i in range (n):
if s[i] == 'W' and prev == 'L' :
ans +=1
l.append(c)
c = 0
elif s[i] == 'W' and prev == 'W':
ans+=2
if s[i]=='L':
c+=1
prev = s[i]
if s[n-1] != 'W':
l.append(c)
p = l.pop(0)
if len(l)>0 and s[n-1]!='W':
q = l.pop()
l.sort()
for i in range (len(l)):
if l[i]<=k:
ans+=(l[i]*2)+1
k-=l[i]
else:
ans+=k*2
k = 0
break
if p == n and k >=n:
ans = 2*p-1
elif p == n and k<n:
ans = max(k*2-1,0)
else:
ans+=min(k,p+q)*2
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int T, n, k, x, ans;
int cnt, p[110000];
char s[110000];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
cnt = 0;
ans = 0;
x = 0;
for (int i = 1; i <= n; i++)
if (s[i] == 'W') {
if (x) p[++cnt] = i - x - 1;
ans++;
x = i;
}
if (!ans) {
if (!k)
puts("0");
else
printf("%d\n", 2 * k - 1);
continue;
}
k = min(k, n - ans);
sort(p + 1, p + cnt + 1);
ans += 2 * k;
for (int i = 1; i <= cnt; i++)
if (p[i] <= k) {
k -= p[i];
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int INF = 0x3f3f3f3f;
constexpr ll LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr double EPS = 1e-8;
constexpr int MOD = 1000000007;
constexpr int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
constexpr int dy8[] = {1, 1, 0, -1, -1, -1, 0, 1},
dx8[] = {0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename U>
inline bool chmax(T &a, U b) {
return a < b ? (a = b, true) : false;
}
template <typename T, typename U>
inline bool chmin(T &a, U b) {
return a > b ? (a = b, true) : false;
}
struct IOSetup {
IOSetup() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} iosetup;
template <typename T = char, typename U = std::string>
std::vector<std::pair<T, int>> rle(const U &s) {
int n = s.size();
std::vector<std::pair<T, int>> res;
T now = s[0];
int cnt = 1;
for (int i = 1; i < n; ++i) {
if (s[i] != now) {
res.emplace_back(now, cnt);
cnt = 0;
}
now = s[i];
++cnt;
}
res.emplace_back(now, cnt);
return res;
}
void solve() {
int n, k;
string s;
cin >> n >> k >> s;
if (count((s).begin(), (s).end(), 'W') == 0) {
cout << (k == 0 ? 0 : 1 + (k - 1) * 2) << '\n';
return;
}
vector<pair<int, int>> len;
{
int idx = 0;
while (s[idx] == 'L') ++idx;
while (idx < n) {
while (idx < n && s[idx] == 'W') ++idx;
if (idx < n) {
int j = idx + 1;
while (j < n && s[j] == 'L') ++j;
if (j < n) len.emplace_back(j - idx, idx);
idx = j;
}
}
}
sort((len).begin(), (len).end(), greater<pair<int, int>>());
while (!len.empty() && k > 0) {
auto [l, st] = len.back();
len.pop_back();
for (int i = (st); i < (st + l); ++i) {
if (k > 0) {
s[i] = 'W';
--k;
}
}
}
if (k > 0) {
int r = n;
while (s[r - 1] == 'L') --r;
for (; r < n; ++r) {
if (k > 0) {
s[r] = 'W';
--k;
}
}
int l = -1;
while (s[l + 1] == 'L') ++l;
for (; l >= 0; --l) {
if (k > 0) {
s[l] = 'W';
--k;
}
}
}
int ans = 0;
for (int i = (0); i < (n); ++i) {
if (s[i] == 'W') ans += i > 0 && s[i - 1] == 'W' ? 2 : 1;
}
cout << ans << '\n';
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 8 | CPP |
import sys
import random
import math
import copy
from heapq import heappush, heappop, heapify
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = float("inf")
MOD = 10 ** 9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def solve():
n, m = getList()
wl = getS()
if "W" not in wl:
num = min(n, m)
if num == 0:
print(0)
else:
print(num * 2 - 1)
return
ans = 0
prev = ""
hashil = 0
ishashi = True
ct = 0
cl = []
for c in wl:
if c == "W":
if prev == "W":
ans += 2
else:
if prev == "L":
if ishashi:
hashil = ct
else:
cl.append(ct)
ct = 0
ans += 1
ishashi = False
else:
ct += 1
prev = c
# print(ans, ": ")
hashil += ct
# print(cl)
cl.sort()
for cc in cl:
if m >= cc:
ans += cc * 2 + 1
m -= cc
else:
ans += m * 2
print(ans)
return
ans += min(hashil, m) * 2
print(ans)
return
def main():
n = getN()
for _ in range(n):
solve()
return
if __name__ == "__main__":
main()
# solve() | 8 | PYTHON3 |
z,zz=input,lambda:list(map(int,z().split()))
fast=lambda:stdin.readline().strip()
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
def solve(n,k,s):
arr=[]
sm=s.count("W")
if sm==0:
return max(min(n,k)*2 -1,0)
arr=s.split("W")[1:-1]
arr=list(filter(None,arr))
arr=[len(i) for i in arr]
arr.sort()
t=len(arr)
ncut=t+1
for i in range(t):
if k>=arr[i]:
sm+=arr[i]
k-=arr[i]
ncut-=1
return max(0,min(2*n-1,(sm+k)*2-ncut))
t = int(input())
for x in range(t):
n,k=zz()
s = fast()
h = solve(n,k,s)
print(h)
| 8 | PYTHON3 |
z,zz=input,lambda:list(map(int,z().split()))
fast=lambda:stdin.readline().strip()
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
import sys,io,os
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
def solve(n,k,s):
arr=[]
sm=0
if "W" not in s:
return max(min(n,k)*2 -1,0)
arr=s.split("W")[1:-1]
arr=list(filter(None,arr))
arr=[len(i) for i in arr]
arr.sort()
sm=s.count("W")
ncut=len(arr)+1
for i in range(len(arr)):
if k>=arr[i]:
sm+=arr[i]
k-=arr[i]
ncut-=1
return max(0,min(2*n-1,(sm+k)*2-ncut))
t = int(input())
for x in range(t):
n,k=zz()
s = fast()
h = solve(n,k,s)
print(h)
| 8 | PYTHON3 |
t = int(input())
for i in range(t):
n,k = map(int,input().strip(' ').split(' '))
s = input().strip(' ')
ind = s.find('W')
if ind == -1:
if k == 0:
print(0)
else:
print((2*k)-1)
continue
pre = 1
c = 0
lcount = []
wins = 1
winningstreak = 0
for i in range(ind+1,n):
if s[i] == 'W':
if pre == 0:
lcount.append(c)
c = 0
wins += 1
pre = 1
else:
if pre == 1:
winningstreak += 1
c += 1
pre = 0
if pre:
winningstreak += 1
wins += k
if wins >= n:
print(2*n - 1)
continue
lcount.sort()
x = 0
for i in lcount:
if k >= i:
x += 1
k -= i
else:
break
ans = 2*(wins) - winningstreak + x
#print('wins= '+str(wins)+'k= '+str(k)+'ws= '+str(winningstreak),x)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
long long int i;
vector<long long int> losing;
long long int winning = 0, wins = 0, loss = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'W') {
wins++;
if (i == 0 || s[i - 1] == 'L') winning++;
} else {
loss++;
if (i == 0 || s[i - 1] == 'W') losing.push_back(0);
losing.back()++;
}
}
if (k >= loss) {
cout << 2 * n - 1 << " ";
cout << "\n";
continue;
}
if (wins == 0) {
if (k == 0)
cout << 0 << " ";
else
cout << 2 * k - 1 << " ";
cout << "\n";
continue;
}
if (s[0] == 'L') losing[0] = 1e8;
if (s[n - 1] == 'L') losing.back() = 1e8;
sort(losing.begin(), losing.end());
wins += k;
for (auto it : losing) {
if (it > k) break;
k -= it;
winning--;
}
cout << (2 * wins) - winning << " ";
cout << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, k;
cin >> n >> k;
string str;
cin >> str;
int wins = 0;
for (int j = 0; j < n; j++) {
char ch = str[j];
if (ch == 'W') {
wins++;
}
}
if (k >= n - wins) {
cout << 2 * n - 1 << endl;
continue;
}
int streaks = 0;
bool lastWin = false;
bool lastLost = false;
vector<int> streak_gaps;
for (int j = 0; j < n; j++) {
char ch = str[j];
if (ch == 'W') {
if (!lastWin) {
streak_gaps.push_back(1);
} else
streak_gaps[streak_gaps.size() - 1]++;
lastWin = true;
lastLost = false;
} else {
if (!lastLost) {
streak_gaps.push_back(-1);
} else
streak_gaps[streak_gaps.size() - 1]--;
lastLost = true;
lastWin = false;
}
}
if (streak_gaps.size() > 0 && streak_gaps[streak_gaps.size() - 1] < 0)
streak_gaps.pop_back();
if (streak_gaps.size() > 0 && streak_gaps[0] < 0)
streak_gaps.erase(streak_gaps.begin());
for (auto it = streak_gaps.begin(); it != streak_gaps.end(); it++) {
if (*it > 0) {
it = streak_gaps.erase(it);
it--;
streaks++;
} else
*it = -*it;
}
sort(streak_gaps.begin(), streak_gaps.end());
int fills = 0;
int filled_gaps = 0;
for (auto it = streak_gaps.begin(); it != streak_gaps.end(); it++) {
int gap = *it;
if (fills + gap > k) {
break;
}
fills += gap;
filled_gaps++;
}
int ans = 2 * (k + wins) - streaks + filled_gaps;
if (wins == 0)
cout << max(0, ans - 1) << "\n";
else
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
namespace number_theory {
long long gcd(long long x, long long y) {
if (x == 0) return y;
if (y == 0) return x;
return gcd(y, x % y);
}
bool isprime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool prime[15000105];
void sieve(long long n) {
for (long long i = 0; i <= n; i++) prime[i] = 1;
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
prime[1] = prime[0] = 0;
}
vector<long long> primelist;
bool __primes_generated__ = 0;
void genprimes(long long n) {
__primes_generated__ = 1;
sieve(n + 1);
for (long long i = 2; i <= n; i++)
if (prime[i]) primelist.push_back(i);
}
vector<long long> factors(long long n) {
if (!__primes_generated__) {
cerr << "Caint genprimes you dope" << endl;
exit(1);
}
vector<long long> facs;
for (long long i = 0;
primelist[i] * primelist[i] <= n && i < primelist.size(); i++) {
if (n % primelist[i] == 0) {
while (n % primelist[i] == 0) {
n /= primelist[i];
facs.push_back(primelist[i]);
}
}
}
if (n > 1) {
facs.push_back(n);
}
sort(facs.begin(), facs.end());
return facs;
}
vector<long long> getdivs(long long n) {
vector<long long> divs;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
divs.push_back(i);
divs.push_back(n / i);
}
}
{
sort(divs.begin(), divs.end());
divs.erase(unique(divs.begin(), divs.end()), divs.end());
};
return divs;
}
} // namespace number_theory
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long win = 0, loss = 0, winning_streak_cnt = 0;
vector<long long> lossing_streak;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
win++;
if (i == 0 or s[i - 1] == 'L') winning_streak_cnt++;
} else {
loss++;
if (i == 0 or s[i - 1] == 'W') lossing_streak.push_back(0);
lossing_streak.back()++;
}
}
if (k >= loss) {
cout << 2 * n - 1 << "\n";
return;
}
if (win == 0) {
if (k == 0)
cout << 0;
else
cout << 2 * k - 1;
cout << "\n";
return;
}
win += k;
if (s[0] == 'L') lossing_streak[0] = 1e8;
if (s[n - 1] == 'L') lossing_streak.back() = 1e8;
sort(lossing_streak.begin(), lossing_streak.end());
for (long long ls : lossing_streak) {
if (ls > k) break;
k -= ls;
winning_streak_cnt--;
}
cout << 2 * win - winning_streak_cnt << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, N, K;
string s;
for (cin >> T; T; T--) {
cin >> N >> K;
cin >> s;
int start = 0, end = N;
int ans = -1;
vector<int> runLens(1, 0);
while (start < N && s[start] == 'L') start++;
while (end > 0 && s[end - 1] == 'L') end--;
if (end == 0) {
cout << max(K * 2 - 1, 0) << endl;
continue;
}
for (int i = start; i < end; i++)
if (s[i] == 'L')
runLens[runLens.size() - 1]++;
else if (runLens.back()) {
runLens.push_back(0);
ans++;
} else
ans += 2;
runLens.pop_back();
sort(runLens.begin(), runLens.end());
for (int i = 0; i < runLens.size(); i++)
if (K >= runLens[i]) {
K -= runLens[i];
ans += 2 * runLens[i] + 1;
} else {
ans += K * 2;
K = 0;
}
ans += min(K, start + (N - end)) * 2;
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("avx")
const long long INF = numeric_limits<long long>::max();
const long double PI = 3.1415926535898;
const long long MOD = 1000000007;
const long long LIM = 100005;
long long fpow(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = fpow(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sieve(long long n) {
bool prime[5 * LIM];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++)
if (prime[p] == true)
for (long long i = p * p; i <= n; i += p) prime[i] = false;
prime[1] = 0;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
map<long long, long long> primeFactors(long long n) {
map<long long, long long> mp;
while (n % 2 == 0) {
if (mp.count(2) == 1)
mp[2]++;
else
mp.insert({2, 1});
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
if (mp.count(i) == 1)
mp[i]++;
else
mp.insert({i, 1});
n = n / i;
}
}
if (n > 2) {
if (mp.count(n) == 1)
mp[n]++;
else
mp.insert({n, 1});
}
return mp;
}
void solve() {
long long n, k, ans = 0, st = -1;
cin >> n >> k;
string s;
cin >> s;
vector<vector<long long>> v;
v.clear();
bool f1 = false, f2 = false;
for (long long i = 0; i + 1 < n; i++) {
if (s[i] == 'W' && s[i + 1] == 'L') st = i + 1;
if (s[i] == 'L' && s[i + 1] == 'W') {
if (st != -1) v.push_back({i - st + 1, st, i});
st = 0;
}
}
sort(v.begin(), v.end());
;
for (auto x : v) {
for (long long j = x[1]; j <= x[2]; j++) {
if (k <= 0) {
f1 = true;
break;
}
s[j] = 'W';
k--;
}
if (f1) break;
}
if (k > 0) {
st = n;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') st = i;
}
for (long long i = st + 1; i < n; i++) {
if (k <= 0) {
break;
}
k--;
s[i] = 'W';
}
st = n;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
st = i;
break;
}
}
for (long long i = st - 1; i >= 0; i--) {
if (k <= 0) break;
k--;
s[i] = 'W';
}
for (long long i = 0; i < n; i++) {
if (k <= 0) break;
if (s[i] == 'W') continue;
k--;
s[i] = 'W';
}
}
if (s[0] == 'W') ans++;
for (long long i = 1; i < n; i++) {
if (s[i] == 'W' && s[i - 1] == 'W')
ans += 2;
else if (s[i] == 'W')
ans++;
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (long long tt = 1; tt <= t; ++tt) {
solve();
}
return 0;
}
| 8 | CPP |
import sys
lines = sys.stdin.readlines()
cur_line = -1
def input():
global lines, cur_line
cur_line += 1
return lines[cur_line][:-1]
for _ in range(int(input())):
n,k = map(int,input().split())
s = input()
base = 0
gaps = []
for i in range(n):
if s[i] == 'W':
base += 1 if i == 0 or s[i-1] == 'L' else 2
elif s[i] == 'L':
if i == 0 or s[i-1] == 'W':
gaps.append(1)
else:
gaps[-1] += 1
#print(gaps, base)
if len(gaps) > 0:
if s[0] == 'L':
gaps[0] = 9999999
if s[-1] == 'L':
gaps[-1] = 9999999
#print(gaps, base)
gaps.sort()
c = 0
su = 0
for i in gaps:
su += i
if su <= k:
base += 1
t = sum(1 for c in s if c == 'L')
off = 1 if t == n else 0
print(max(0, base + min(k,t) * 2 - off))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, i, j, x, y, sum = 0, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> v;
for (i = 0; i < n; ++i)
if (s[i] == 'W') v.push_back(i);
x = v.size();
priority_queue<vector<long long>> pq;
for (i = 1; i < x; ++i) {
vector<long long> a;
a.push_back(v[i - 1] - v[i]);
a.push_back(v[i - 1]);
a.push_back(v[i]);
pq.push(a);
}
while (k && !pq.empty()) {
vector<long long> a = pq.top();
pq.pop();
for (i = a[1] + 1; i < a[2] && k; ++i)
if (s[i] == 'L') s[i] = 'W', --k;
}
if (k && x) {
for (i = v[0] - 1; i >= 0 && k; --i) s[i] = 'W', --k;
for (i = v[x - 1] + 1; i < n && k; ++i) s[i] = 'W', --k;
} else if (k) {
for (i = 0; i < n && k; ++i) s[i] = 'W', --k;
}
if (s[0] == 'W') sum = 1;
for (i = 1; i < n; ++i)
if (s[i] == 'W' && s[i - 1] == 'W')
sum += 2;
else if (s[i] == 'W')
sum += 1;
cout << sum << endl;
}
return 0;
}
| 8 | CPP |
t=int(input())
for _ in range(t):
n,K=map(int,input().split())
s=input()
diff=[0]*(n+1)
prev=0
I=0
J=n-1
flag1,flag2=True,True
for k in range(n):
if s[k]=='W':
I=k
flag1=False
break
for k in range(n-1,-1,-1):
if s[k]=='W':
J=k
flag2=False
break
if flag1 and flag2:
if K>0:
print(2*K-1)
else:
print(0)
continue
prev=I
for k in range(I,J+1):
if s[k]=='W':
if(k>prev+1):
diff[k-prev-1]+=1
prev=k
j=n
ans=0
# print(diff)
for i in range(1,n+1):
if K<i:
j=i
break
ans+=(2*i+1)*(min(K//i,diff[i]))
temp=diff[i]
diff[i]=diff[i]-(min(K//i,diff[i]))
K=K-i*(min(K//i,temp))
# print(diff[i])
ans+=2*(min(K,I))
K=K-min(K,I)
ans+=2*(min(K,n-1-J))
K=K-(min(K,n-1-J))
for k in range(1,n+1):
if K<=0:
break
if diff[k]!=0:
ans+=2*K
K=0
prev=False
# print('ans',str(ans))
for i in range(n):
if s[i]=='W':
if prev:
ans+=2
else:
ans+=1
prev=True
continue
prev=False
print(ans)
| 8 | PYTHON3 |
from collections import deque
for _ in range(int(input())):
n, k = map(int, input().split())
st = input()
side = []
mid = []
tmp = 0
ans = 0
for a in range(n):
if st[a] == "W":
if tmp != 0:
mid.append(tmp)
tmp = 0
ans += 1
elif a == 0:
ans += 1
else:
ans += 2
else:
tmp += 1
if tmp != 0:
side.append(tmp)
if st[0] == "L" and len(mid) > 0:
side.append(mid[0])
mid = mid[1:]
if ans == 0 and k >= 1:
print(2 * min(k, len(st)) - 1)
continue
mid.sort()
side.sort()
midq = deque(mid)
sideq = deque(side)
while k > 0:
if len(midq) > 0 and midq[0] <= k:
tmp = midq.popleft()
ans += (2 * tmp) + 1
else:
if len(midq) == 0 and len(sideq) == 0:
break
elif len(midq) == 0:
tmp = sideq.popleft()
elif len(sideq) == 0:
tmp = midq.popleft()
else:
tmp = sideq.popleft()
ans += 2 * min(tmp, k)
k -= tmp
print(ans)
| 8 | PYTHON3 |
# cook your dish here
#hi
import math
import os
import random
import re
import sys
def maxpts(str1,k):
w=0
losses=[]
ans=0
W=False
cur=0
for c in str1:
if c=='W':
if cur:
losses.append(cur)
cur=0
w+=1
ans+=1
if W:
ans+=1
W=True
else:
W=False
if w:
cur+=1
if w==0:
print(max(2*k-1,0))
return
n=len(str1)
if k>=n-w:
print(n*2-1)
return
ans+=2*k
losses.sort()
for l1 in losses:
if k>=l1:
ans+=1
k=k-l1
else:
break
print(ans)
if __name__=='__main__':
n=int(input())
for i in range(n):
n1,k=map(int,input().rstrip().split())
str1=input()
maxpts(str1,k) | 8 | PYTHON3 |
import sys,math
input=sys.stdin.readline
t=int(input())
for r in range(t):
n, k = map(int,input().split())
s = input().strip("\n")
ans = 0
l = []
for i in s:
l.append(i)
intervals = []
i = 0
left = []
right = []
while i < n:
if l[i] == "W":
i += 1
continue
else:
current = [i,i]
while i <n and l[i] == "L":
i += 1
current[1] = i
if current[0] == 0:
left.append(current)
elif current[1] == n:
right.append(current)
else:
intervals.append(current)
intervals.sort(key = lambda x:abs(x[0]-x[1]))
# for j in left:
# intervals.append(j)
# print(intervals)
# print(left)
# print(intervals)
for interval in intervals:
for i in range(interval[0],interval[1]):
if k > 0:
l[i] = "W"
k -= 1
try:
int1 = left[0]
for i in range(int1[1]-1, int1[0] -1 , -1):
if k > 0:
l[i] = "W"
k -= 1
except:
pass
try:
int2 = right[0]
# print("entered")
for i in range(int2[0],int2[1]):
if k > 0:
l[i] = "W"
k -= 1
except:
pass
# print(l)
for i in range(n):
if l[i] == "W":
if i == 0 or l[i-1]=="L":
ans += 1
else:
ans += 2
# print("ans",ans)
print(ans)
| 8 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
n, k = map(int, input().split())
S = input()
wins = S.count('W')
if k >= n - wins:
print(2 * n - 1)
continue
elif wins == 0 and k:
print(2 * k - 1)
continue
score = 0
good = []
i = S.find('W')
extra = i
cnt = 0
while i < n:
if S[i] == 'L':
cnt += 1
else:
score += 1
if i > 0 and S[i-1] == 'W': score += 1
if cnt: good.append(cnt)
cnt = 0
i += 1
extra += cnt
good.sort()
for j in good:
if k >= j:
score += 1 + 2 * j
k -= j
else:
score += 2 * k
k = 0
if k:
score += 2 * min(k, extra)
print(score)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
inline long long read() {
long long o = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
o = o * 10 + c - '0';
c = getchar();
}
return o * f;
}
} // namespace IO
using namespace IO;
const int N = 1e5 + 7, M = 1e6 + 7, INF = 0x3f3f3f3f, Mod = 1e9 + 7;
char a[N];
int b[N], tot;
int t, n, k;
vector<int> pos;
int main() {
cin >> t;
while (t--) {
tot = 0;
cin >> n >> k;
cin >> a;
int cnt = 0;
bool f = 0;
for (int i = 0, s = 0; i < n; i++) {
if (a[i] == 'W') {
f = 1;
cnt++;
}
if (a[i] == 'L' && f) {
s++;
} else {
if (s > 0) {
b[++tot] = s;
s = 0;
}
}
}
if (cnt + k >= n) {
cout << (2 * n) - 1 << endl;
continue;
}
sort(b + 1, b + 1 + tot);
int t = 0, first = 0;
for (int i = 1; i <= tot; i++) {
t += b[i];
if (t > k) {
first = tot - i + 2;
break;
}
}
if (t <= k && (cnt || k)) {
first = 1;
}
cout << (cnt + k) * 2 - first << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve(int test_case) {
int n, k;
string S;
cin >> n >> k >> S;
int wins = 0;
for (int i = 0; i < n; ++i) {
wins += (S[i] == 'W');
}
if (n - wins <= k) {
cout << max(0, 2 * n - 1) << "\n";
return;
}
if (wins == 0) {
cout << max(0, min(n, k) * 2 - 1) << "\n";
return;
}
vector<int> gaps;
int trip = 0, st = 0, back = 0;
for (int i = 0; i < n; ++i) {
if (S[i] == 'W') {
trip = 1;
continue;
}
if (trip) {
int j = i;
while (i < n && S[i] == 'L') {
++i;
}
if (i == n)
back = i - j;
else
gaps.push_back(i - j);
} else {
while (i < n && S[i] == 'L') {
++i;
++st;
}
trip = 1;
}
}
sort(gaps.begin(), gaps.end());
int swi = 0, ans = 0;
for (int i = 0; i < n; ++i) {
if (S[i] == 'L') {
swi = 0;
continue;
}
if (swi) {
ans += 2;
swi = 1;
} else {
++ans;
swi = 1;
}
}
for (int i = 0; i < ((int)gaps.size()) && k; ++i) {
if (k >= gaps[i]) {
k -= gaps[i];
ans += gaps[i] * 2 + 1;
} else {
ans += 2 * k;
k = 0;
break;
}
}
if (k && st) {
ans += 2 * min(k, st);
k -= min(k, st);
}
if (k && back) {
ans += 2 * min(k, back);
k -= min(k, back);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t, test_case = 0;
cin >> t;
for (; test_case < t; ++test_case) {
solve(test_case);
}
return 0;
}
| 8 | CPP |
from functools import lru_cache
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
t = inp()
for _ in range(t):
n, k = inlt()
s = insr()
# score = 0
# for i, ch in enumerate(s):
# if ch == "W":
# score += 1
# if i > 0 and s[i-1] == "W":
# score += 1
# @lru_cache(None)
# def dp(i, rem):
# if rem == 0 or i == n:
# return 0
# res = 0
# for j in range(i, n):
# if s[j] == "L":
# s[j] = "W"
# ad = 1
# if j > 0 and s[j-1] == "W":
# ad += 1
# if j < n - 1 and s[j+1] == "W":
# ad += 1
# res = max(res, ad + dp(j+1, rem-1))
# s[j] = "L"
# return res
# max_add = dp(0, k)
# print(score+max_add)
if k > 0:
l_groups = []
i = 0
while i < n:
group = []
while i < n and s[i] == "L":
group.append(i)
i+=1
if group:
l_groups.append(group)
i += 1
start, end = [], []
if l_groups and l_groups[0][0] == 0:
start = l_groups.pop(0)
if l_groups and l_groups[-1][-1] == n-1:
end = l_groups.pop()
l_groups.sort(key = lambda a : (len(a)))
for group in l_groups:
for i in group:
s[i] = "W"
k -= 1
if k == 0:
break
if k == 0:
break
rem = start[::-1] + end
for i in range(min(k, len(rem))):
s[rem[i]] = "W"
score = 0
for i, ch in enumerate(s):
if ch == "W":
score += 1
if i > 0 and s[i-1] == "W":
score += 1
print(score)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <typename T>
void cins(T &first) {
cin >> first;
}
template <typename T, typename... Ts>
void cins(T &first, T &second, Ts &...rest) {
cin >> first;
cins(second, rest...);
}
const long long mod = pow(10, 9) + 7;
const long long N = 3e5, M = N;
const long long inf = LLONG_MAX;
const long long infn = LLONG_MIN;
void iluzn() {
long long n, k;
cins(n, k);
string s;
cins(s);
long long res = 0;
long long w = 0, l = 0, ws = 0;
vector<long long> ls;
for (long long i = 0; i < (long long)n; i += 1) {
if (s[i] == 'W') {
w++;
if (i == 0 || s[i - 1] == 'L') ws++;
} else {
l++;
if (i == 0 || s[i - 1] == 'W') ls.push_back(0);
ls.back()++;
}
}
if (k >= l) {
cout << 2 * n - 1 << "\n";
return;
}
if (w == 0) {
if (k)
cout << 2 * k - 1 << "\n";
else
cout << 0 << "\n";
return;
}
if (s[0] == 'L') ls[0] = inf;
if (s[n - 1] == 'L') ls.back() = inf;
sort(ls.begin(), ls.end());
w += k;
for (long long i = 0; i < (long long)ls.size(); i += 1) {
if (ls[i] <= k) {
k -= ls[i];
ws--;
} else
break;
}
cout << 2 * w - ws << "\n";
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
cin >> t;
while (t--) iluzn();
return 0;
}
| 8 | CPP |
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
def main():
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
for _ in range(ri()):
n,k=ria()
s=rs()
consgaps=[]
currconsgaps=0
prevscore=0
for i in range(n):
if s[i]=='W':
if i-1>=0 and s[i-1]=='W':
prevscore+=2
else:
prevscore+=1
L,R=0,n-1
for i in range(n):
if s[i]=='W':
L=i
break
for i in range(n-1,-1,-1):
if s[i]=='W':
R=i
break
s=s[L:R+1]
# print(s)
if k==0:
print(prevscore)
elif prevscore==0:
print(2*(min(n,k))-1)
else:
ngapsleftovers=(L+n-1-R)
for i in range(len(s)):
if s[i]=='W':
if currconsgaps>0:
consgaps.append(currconsgaps)
currconsgaps=0
else:
currconsgaps+=1
if currconsgaps>0:
consgaps.append(currconsgaps)
# print(consgaps)
z=sorted(consgaps)
# print(z)
newscore=prevscore
for i in z:
if k-i<0:
newscore+=2*k
k=0
break
else:
newscore+=2*i+1
k-=i
if k>0:
newscore+=2*min(ngapsleftovers,k)
print(newscore)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
int l = 1;
int index = i;
while (i + 1 < n && s[i + 1] == 'L') {
i++;
l++;
}
if (index == 0 || i == n - 1) {
} else
pq.push(make_pair(l, index));
}
}
while (!pq.empty() && k > 0) {
pair<int, int> p = pq.top();
pq.pop();
int index = p.second;
for (int i = index; i < n && k > 0; i++) {
if (s[i] == 'W') break;
s[i] = 'W';
k--;
}
}
if (k > 0) {
int index = n - 1;
for (; index >= 0 && k > 0; index--) {
if (s[index] == 'W') break;
}
index++;
for (int i = index; i < n && k > 0; i++) {
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
index = 0;
for (; index < n && k > 0; index++) {
if (s[index] == 'W') break;
}
for (int i = index; i >= 0 && k > 0; i--) {
if (s[i] == 'L') {
k--;
s[i] = 'W';
}
}
}
int score = s[0] == 'W';
for (int i = 1; i < n; i++) {
if (s[i] == 'W' && s[i - 1] == 'W')
score += 2;
else if (s[i] == 'W')
score++;
}
cout << score << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int T;
cin >> T;
while (T--) {
int n, k;
string s;
cin >> n >> k;
cin >> s;
vector<int> id;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W') {
id.push_back(i);
}
}
vector<tuple<int, int, int>> diffs;
for (int i = 1; i < id.size(); i++) {
if (id[i] - id[i - 1] - 1 >= 1) {
diffs.emplace_back(id[i] - id[i - 1] - 1, id[i - 1], id[i]);
}
}
sort(diffs.begin(), diffs.end());
for (int i = 0; i < diffs.size(); i++) {
int a, b, c;
tie(a, b, c) = diffs[i];
if (a <= k) {
for (int i = b; i <= c; i++) {
s[i] = 'W';
}
k -= a;
}
}
int sol = 0;
int los = 0;
for (int i = 0; i < s.size(); i++) {
if (i == 0) {
sol += (s[i] == 'W');
} else {
if (s[i] == 'W') {
sol++;
sol += (s[i - 1] == 'W');
}
}
if (s[i] == 'L') {
los++;
}
}
cout << (sol + min(los, k) * 2 - (k && los == n)) << "\n";
}
}
| 8 | CPP |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
s=input()
Wstreak=wins=loss=0
Lstreak=[]
for i in range(n):
if(s[i]=="W"):
wins+=1
if(i==0 or s[i-1]=="L"):
Wstreak+=1
elif(s[i]=="L"):
loss+=1
if(i==0 or s[i-1]=="W"):
Lstreak.append(0)
Lstreak[-1]+=1
if(k>=loss):
print(2*n-1)
elif(wins==0):
if(k==0):
print(0)
else:
print(2*k-1)
else:
if(s[0]=="L"):
Lstreak[0]=1e8
if(s[-1]=="L"):
Lstreak[-1]=1e8
Lstreak.sort()
wins+=k
for i in Lstreak:
if(i>k):
break
k-=i
Wstreak-=1
print(2*wins-Wstreak)
| 8 | PYTHON3 |
I=input
for _ in[0]*int(I()):
n,k=map(int,I().split());s=I();c=s.count('W');n=min(n,c+k);a=sorted(map(len,filter(None,s.strip('L').split('W'))))
while a and c+a[0]<=n:c+=a.pop(0)
print((2*n-len(a)or 1)-1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int ll_max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
int int_max(int a, int b, int c) { return max(a, max(b, c)); }
long long int ll_min(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
int int_min(int a, int b, int c) { return min(a, min(b, c)); }
long long int max(int a, long long int b) { return max((long long int)a, b); }
long long int min(int a, long long int b) { return min((long long int)a, b); }
long long int min(long long int a, int b) { return min(a, (long long int)b); }
long long int max(long long int a, int b) { return max(a, (long long int)b); }
long long int maximum(long long int a[], long long int n) {
long long int max1 = LLONG_MIN;
for (long long int i = 0; i < n; i++) {
max1 = max(max1, a[i]);
}
return max1;
}
long long int minimum(long long int a[], long long int n) {
long long int min1 = LLONG_MAX;
for (long long int i = 0; i < n; i++) {
min1 = min(min1, a[i]);
}
return min1;
}
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int a = power(x, y / 2, m);
if (y % 2) {
return (a * ((a * x) % m)) % m;
} else {
return (a * a) % m;
}
}
long long int mod_inverse(long long int x, long long int m) {
return power(x, m - 2, m);
}
long long int fact(long long int n, long long int m) {
if (n <= 1) return 1;
return (fact(n - 1, m) * n) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r > n) return 0;
long long int n1 = 1, d1 = 1, d2 = 1;
n1 = fact(n, m);
d1 = fact(r, m);
d2 = fact(n - r, m);
long long int ans = mod_inverse((d1 * d2) % m, m);
ans = (ans * n1) % m;
return ans;
}
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0) return max(a, b);
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long int ispal(string s) {
long long int len = s.size();
long long int flag = 1;
for (long long int i = 0; i < len; ++i) {
if (s[i] != s[len - i - 1]) {
flag = 0;
break;
}
}
return flag;
}
long long int sroot(long long int n, long long int low = 1,
long long int high = 1e9 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid;
if (a > n)
return sroot(n, low, mid - 1);
else
return sroot(n, mid, high);
}
long long int croot(long long int n, long long int low = 1,
long long int high = 1e6 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid * mid;
if (a > n)
return croot(n, low, mid - 1);
else
return croot(n, mid, high);
}
unsigned long long int catalan(unsigned long long int n) {
if (n <= 1) return 1;
unsigned long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += catalan(i) * catalan(n - i - 1);
}
return ans;
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
class solver {
public:
void solve() {
long long int n, k;
cin >> n >> k;
string str;
cin >> str;
long long int ans = 0, ind = -1;
vector<pair<int, int>> v;
long long int f = -1, l = -1;
for (long long int i = 0; i < n; i++) {
if (str[i] == 'W') {
if (f == -1) f = i;
ind = i;
long long int p = 0;
l = i;
while (i + 1 < n && str[i + 1] != 'W') i++, p++;
if (p > 0 && i + 1 < n && str[i + 1] == 'W') v.push_back({p, ind});
}
}
sort(v.begin(), v.end());
if (ind == -1) {
for (long long int i = 0; i < k; i++) str[i] = 'W';
} else {
for (long long int i = 0; i < v.size(); i++) {
if (k >= v[i].first) {
k -= v[i].first;
for (long long int j = v[i].second + 1; j <= v[i].second + v[i].first;
j++)
str[j] = 'W';
} else {
for (long long int j = v[i].second + 1; j <= v[i].second + v[i].first;
j++) {
if (k == 0) break;
if (str[j] == 'L') {
str[j] = 'W';
k--;
}
}
k = 0;
break;
}
}
for (long long int i = l + 1; i < n; i++) {
if (k == 0) break;
if (str[i] == 'L') str[i] = 'W', k--;
}
for (long long int i = f - 1; i >= 0; i--) {
if (k == 0) break;
if (str[i] == 'L') str[i] = 'W', k--;
}
}
for (long long int i = 0; i < n; i++) {
long long int c = 0;
if (str[i] == 'W') {
c = 1;
if (i - 1 >= 0 && str[i - 1] == 'W') c++;
ans += c;
}
}
cout << ans << "\n";
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int test = 1, c = 1;
cin >> test;
while (test--) {
solver o;
o.solve();
}
}
| 8 | CPP |
# your code goes here
test = int(input())
for _ in range(test):
n,k = map(int, input().split())
arr = list(input())
less = []
over = []
wins = 0
last = False
pre = 0
found = False
for i in range(n):
if arr[i]=='W':
if last:
# print(i)
wins+=2
else:
wins+=1
if pre<=k and found:
if pre>0:
less.append(pre)
else:
over.append(pre)
found = True
last = True
pre = 0
else:
pre+=1
last = False
if pre:
over.append(pre)
pre = 0
less.sort()
ans = 0
for i in range(len(less)):
if less[i]<=k:
ans += less[i]*2+1
k -= less[i]
else:
over.append(less[i])
v = min(k, sum(over))
if wins==0:
ans += max((v*2)-1, 0)
else:
ans += (2*v)
print(ans+wins) | 8 | PYTHON3 |
# Author : -pratyay-
import sys
inp=sys.stdin.buffer.readline
inar=lambda: list(map(int,inp().split()))
inin=lambda: int(inp())
inst=lambda: inp().decode().strip()
wrt=sys.stdout.write
pr=lambda *args,end='\n': wrt(' '.join([str(x) for x in args])+end)
enum=enumerate
inf=float('inf')
cdiv=lambda x,y: (-(-x//y))
# Am I debugging ? Check if I'm using same variable name in two places
# fun() returning empty list ? check new=temp[:] or new=temp
_T_=int(input())
for _t_ in range(_T_):
n,k=list(map(int,input().split()))
s=list(input())
if k>=s.count('L'):
print(2*n-1)
continue
w=0
l=0
prev=' '
val=[]
ans=0
for i in s:
#print(i,w,l)
if i=='W' and prev=='W':
ans+=2
if i=='W' and prev!='W':
ans+=1
if i!=prev:
if prev==' ':
val.append(0)
elif prev=='W':
val.append(2*w)
w=0
else:
val.append(2*l+1)
l=0
if i=='W':
w+=1
else:
l+=1
prev=i
if w==0:
val.append(2*l+1)
val.append(0)
elif l==0:
val.append(2*w)
ar=[]
for i in range(len(val)-2):
w1,l,w2=val[i],val[i+1],val[i+2]
if w1%2==0 and l%2==1 and w2%2==0:
ar.append((w1,l,w2))
#print(ar)
tmp=[]
for i in ar:
if i[0]==0 or i[2]==0:
tmp.append(i)
ar.remove(i)
ar.sort(key=lambda x: x[1])
tmp.sort(key=lambda x: x[0]+x[2])
ar.extend(tmp)
ar.reverse()
while(k>0 and ar):
w1,l,w2=ar.pop()
w1//=2;l//=2;w2//=2
if l<=k:
if w1>0 and w2>0:
ans+=2*l + 1
elif w1==0 and w2==0:
ans+=2*l-1
else:
ans+=2*l
k-=l
else:
if w1==w2==0:
ans+=2*k-1
k=0
else:
ans+=2*k
k=0
print(ans) | 8 | PYTHON3 |
import sys, os, io
I = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
for tc in range(1, 1 + int(I())):
n, k = map(int, I().split())
s = I().rstrip().decode("utf-8")
if s.find('W') == -1:
ans = max(0,2 * k - 1)
print(ans)
continue
b = 0 # Ls at beginning
l = []
i = 0
while i < n:
if s[i] == 'W':
break
else:
b += 1
i += 1
a = 0
while i < n:
if s[i] == 'W':
if a > 0:
l.append(a)
a = 0
else:
a += 1
i += 1
e = a
l.sort()
ans = 0
for i in range(n):
if s[i] == 'W':
ans += 1
if i > 0:
if s[i-1] == 'W':
ans += 1
for c in l:
if c <= k:
k -= c
ans += 2 * c + 1
else:
if k > 0:
ans += 2 * k
k = 0
ans += 2 * min(k, b+e)
print(ans)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k = map(int,input().split(' '))
s = input()
if s[0]=='W':
score = 1
else:
score = 0
for i in range(1,n):
if s[i]=='W':
if s[i-1]=='W':
score = score + 2
else:
score = score + 1
start = []
i = 0
while i<n:
if s[i]=='L':
j = i + 1
a = [i]
while j<n and s[j]=='L':
j = j + 1
i = j
a.append(i)
start.append(a)
else:
i = i + 1
add_score = 0
f = 0
p = 0
if len(start)>0:
if start[0][0]==0:
p = start[0][1] - start[0][0]
s1 = start[1:len(start)]
f = 1
else:
s1 = start
g = 0
p1 = 0
if len(s1)!=0:
if s1[-1][1]==n:
p1 = s1[-1][1] - s1[-1][0]
s1 = s1[0:len(s1)-1]
g = 1
for item in s1:
item.append(item[1]-item[0])
s1.sort(key=lambda x:x[2])
t = len(s1)
for item in s1[0:t]:
if k>=item[2]:
k = k - item[2]
add_score = add_score + 2*item[2] + 1
else:
add_score = add_score + 2*k
k = 0
if k==0:
break
if f==1 or g==1 and k!=0:
add_score = add_score + 2*min(p+p1,k)
if n==1:
if k>=n:
print(1)
else:
if s=='W':
print(1)
else:
print(0)
else:
if len(set(s))==1 and s[0]=='L':
print(max(0,score+add_score-1))
else:
print(score+add_score)
else:
print(score) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
string s;
cin >> n >> k >> s;
int loss = 0, prev = -1, score = 0;
vector<int> gaps;
int gap = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
gap++;
loss++;
} else if (s[i] == 'W') {
score++;
if (i && s[i - 1] == 'W') {
score++;
}
if (gap && prev >= 0) {
gaps.push_back(gap);
}
gap = 0;
prev = i;
}
}
sort(gaps.begin(), gaps.end());
k = min(k, loss);
for (int i = 0; i < gaps.size() && k - gaps[i] >= 0; i++) {
k -= gaps[i];
score += 2 * gaps[i] + 1;
}
score += 2 * k;
if (loss == n && k > 0) {
score--;
}
cout << score << '\n';
}
}
| 8 | CPP |
def calc(p,n):
score = p[0]
for i in range(1, n):
if (p[i] and p[i - 1]):
score += 2
elif (p[i]):
score += 1
return score
for _ in range(int(input())):
n,k = map(int,input().split())
p = [1 if i=="W" else 0 for i in input()]
if(all(i==0 for i in p)):
if(k>=n):
print(max(2*n-1,0))
else:
print(max(0,2*k-1))
continue
if(k==0):
print(calc(p,n))
continue
ord,cs = [],[]
ans = 0
i = 0
while(i<n):
l, r = i, i
if(p[i]):
while(r+1<n and p[r+1]):
r+=1
ans += (r-l)*2+1
i = r+1
continue
while (r + 1 < n and p[r + 1]==0):
r += 1
if(l!=0 and r!=n-1):
ord.append(r-l+1)
else:
cs.append(r-l+1)
i=r+1
ord.sort()
cs.sort()
ok = True
for i in ord:
if(k==0):
print(ans)
ok = False
break
if(k>=i):
ans += 2*i+1
k-=i
else:
ans+=2*k
print(ans)
ok = False
break
if(not ok):
continue
for i in cs:
if (k == 0):
print(ans)
ok = False
break
if (k >= i):
ans += 2 * i
k -= i
else:
ans += 2 * k
print(ans)
ok = False
break
if (not ok):
continue
print(ans)
| 8 | PYTHON3 |
for i in range(int(input())):
n,k = map(int, input().split())
lst = input()
count = 0; last = -1
ans = []
for i in range(len(lst)):
if lst[i] == 'L':
continue
count += 1
if (last != -1 and last != i-1):
ans += [i - last - 1]
last = i
ans.sort()
mx = len(ans) + 1
for i in range(len(ans)):
if k >= ans[i]:
count += ans[i]
k -= ans[i]
mx -= 1
print(max(0,min(2*n-1,(count+k)*2 -mx)))
| 8 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
s=input()
if 'W' not in s:
ans = min(n,k)*2-1
print(max(ans,0))
else:
extra=0
i=0
while i<n and s[i]=='L':
i+=1
extra=i
j=n-1
while j>=0 and s[j]=='L':
j-=1
extra+=1
c=[]
while i<=j:
if s[i]=='W':
i+=1
else:
m=0
while i<=j and s[i]=='L':
m+=1
i+=1
c.append(m)
c.sort()
ans=0
i=0
while i<n:
if s[i]=='W':
ans+=1
i+=1
while i<n and s[i]=='W':
i+=1
ans+=2
else:
i+=1
for j in c:
if k>=j:
ans+=j*2+1
k-=j
else:
ans+=k*2
k=0
break
ans+=min(k,extra)*2
print(ans)
| 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
s = input()
s = s.replace('WL', 'W L').replace('LW', 'L W')
s = s.split()
ls = [len(li) for li in s if li[0] == 'L']
wstr = 0
for si in s:
wstr+=(si[0]=='W')
wins = n-sum(ls)
if wins+k >= n:
print(n*2-1)
continue
if not wins:###
if k==0:print(k)
else:print(2*k-1)
continue
wins += k
if s[0][0] == 'L':
ls[0] = 1e10
if s[-1][0] == 'L':
ls[-1] = 1e10
ls.sort()
for li in ls:
if li > k:
break
wstr -= 1
k -= li
print(wins*2-wstr)
| 8 | PYTHON3 |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n,k = map(int,input().split())
s = input().strip()
if n == 1:
if s[0] == "W" or k:
print(1)
else:
print(0)
continue
curr = int(s[0]=='W')
for i in range(1,n):
if s[i]=='W':
curr += 1+int(s[i-1]=='W')
fl,cou = 0,0
loss = []
le = 0
for i in range(n):
if s[i]=='W':
fl = 1
if cou:
loss.append(cou)
cou = 0
elif fl:
cou += 1
else:
le += 1
if le == n:
print(max(0,2*min(n,k)-1))
continue
re = cou
loss.sort()
i = 0
while i != len(loss):
if k >= loss[i]:
k -= loss[i]
curr += 2*loss[i]+1
elif k < loss[i]:
curr += 2*k
k = 0
break
i += 1
curr += min(re+le,k)*2
print(curr)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main() | 8 | PYTHON3 |
for _ in range (int(input())):
n,k=map(int,input().split())
a=input()
lc=a.count('L')
z=[]
curr=0
for i in range (n):
if a[i]=='L':
curr+=1
else:
if curr>0:
z.append(curr)
curr=0
ini=[]
if a[0]=='L' and len(z)>0:
ini.append(z[0])
z=z[1:]
if curr>0:
ini.append(curr)
z.sort()
ini.sort()
res=0
s=0
i=0
while i<len(z):
if s+z[i]<=k:
res+=2*z[i]+1
s+=z[i]
else:
break
i+=1
if s<k and i!=len(z):
res+=(k-s)*2
s=k
if s<k and len(ini)>0:
if s+ini[0]<=k:
s+=ini[0]
res+=2*ini[0]
if lc==n:
res-=1
else:
res+=(k-s)*2
if lc==n:
res-=1
s=k
if len(ini)>1:
if s+ini[1]<=k:
s+=ini[1]
res+=2*ini[1]
else:
res+=(k-s)*2
s=k
if a[0]=='W':
res+=1
for i in range (1,n):
if a[i]=='W':
res+=1
if a[i-1]=='W':
res+=1
print(res) | 8 | PYTHON3 |
#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
# @Time : 2020/10/21 11:54 AM
# @Author : Songtao Li
import re
def cal_base_score(input_string):
W_list = re.findall("W+", input_string)
score = sum([2 * (len(w) - 1) + 1 for w in W_list])
return score
if __name__ == "__main__":
total_samples = int(input())
for i in range(total_samples):
length, modify = map(int, input().split())
string = input()
w_count = string.count("W")
l_count = length - w_count
base_score = cal_base_score(string)
if "W" not in string:
print(max(0, 2 * modify - 1))
else:
start = string.find("W")
end = string.rfind("W")
if start == end:
s = "W"
else:
s = string[start:end]
stack = sorted(re.findall("L+", s), reverse=True)
while modify > 0 and len(stack) > 0:
seg = stack.pop()
modify -= 1
if seg == "L":
base_score += 3
else:
base_score += 2
stack.append(seg.replace("L", "", 1))
first_l_seg = string[:start]
last_l_seg = string[end:]
if modify > 0:
for _ in range(len(first_l_seg) + len(last_l_seg)):
base_score += 2
modify -= 1
if modify <= 0:
break
base_score = min(base_score, 2*length-1)
print(base_score)
| 8 | PYTHON3 |
from collections import deque
t=int(input())
while(t):
n,k=map(int,input().split())
s=input()
for x in range(n):
if s[x]=='W':
break
m=x
u=0
d=deque()
for y in range(x,n):
if(s[y]=='L'):
u+=1
if s[y]=='W' and u>0:
d.append(u)
u=0
b=u
l=len(d)
d=sorted(d)
score=0
wins=0
for x in range(n):
if s[x]=='W':
wins+=1
if(x>0 and s[x-1]=='W'):
score+=2
else:
score+=1
# print(d)
for x in range(l):
if(k>=d[x]):
score=score+d[x]*2+1
k-=d[x]
elif k>0 and k<d[x]:
score=score+k*2
k=0
# print(score)
# print(b,m)
if k>0:
if wins==0:
score=score+(k-1)*2+1
elif m+b<=k:
score=score+(m+b)*2
elif m+b>k :
score=score+k*2
print(score)
t-=1 | 8 | PYTHON3 |
class Streak:
def __init__(self, start_ind, end_ind):
self.start_ind = start_ind
self.end_ind = end_ind
class StreakNbors:
def __init__(self, streak_a, streak_b):
self.streak_a = streak_a
self.streak_b = streak_b
def get_gap(self):
return (self.streak_b.start_ind - self.streak_a.end_ind) - 1
def close_gap(self):
self.streak_a.end_ind += 1
t = int(input())
for it in range(0, t):
n, k = tuple(list(map(int, input().split(' '))))
results = [char for char in input()]
if n == 1:
if k >= 1:
results[0] = 'W'
else:
streak_list = []
current_streak = None
for i in range(0, len(results)):
if results[i] == 'W':
if i == 0 or results[i - 1] == 'L':
current_streak = Streak(i, i)
streak_list.append(current_streak)
else:
current_streak.end_ind = i
if streak_list:
streak_nbors_list = []
for i in range(0, len(streak_list) - 1):
streak_nbors_list.append(StreakNbors(streak_list[i], streak_list[i + 1]))
streak_nbors_list = sorted(streak_nbors_list, key=lambda streak_nbors: streak_nbors.get_gap())
streak_nbors_ind = 0
changes = 0
while changes < k and streak_nbors_ind < len(streak_nbors_list):
current_streak_nbors = streak_nbors_list[streak_nbors_ind]
if current_streak_nbors.get_gap() > 0:
current_streak_nbors.close_gap()
changes += 1
else:
streak_nbors_ind += 1
for i in range(0, len(streak_nbors_list)):
current_streak_nbors = streak_nbors_list[i]
streak_a_start_ind = current_streak_nbors.streak_a.start_ind
streak_a_end_ind = current_streak_nbors.streak_a.end_ind
for j in range(streak_a_start_ind, streak_a_end_ind + 1):
results[j] = 'W'
streak_b_start_ind = current_streak_nbors.streak_b.start_ind
streak_b_end_ind = current_streak_nbors.streak_b.end_ind
for j in range(streak_b_start_ind, streak_b_end_ind + 1):
results[j] = 'W'
min_streak_ind = 200001
max_streak_ind = -1
for i in range(0, len(results)):
if results[i] == 'W':
min_streak_ind = min(i, min_streak_ind)
max_streak_ind = max(i, min_streak_ind)
while changes < k:
if min_streak_ind > 0:
min_streak_ind -= 1
results[min_streak_ind] = 'W'
changes +=1
elif max_streak_ind < len(results) - 1:
max_streak_ind += 1
results[max_streak_ind] = 'W'
changes += 1
else:
break
else:
for i in range(0, k):
results[i] = 'W'
score = 0
for i in range(0, n):
if results[i] == 'W':
score += 1
if i > 0 and results[i - 1] == 'W':
score += 1
print(score)
| 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
s = str(input())
a = 0
b = 0
kek = []
fl = 0
su = 0
rs = 0
buf = 1e10
buf1 = 1e10
for i in range(len(s)):
if s[i] == 'W':
if a > 0:
su += a
if fl == 0:
buf1 = a
else:
kek.append(a)
a = 0
fl = 1
b += 1
else:
if b > 0:
rs += 2*(b-1) + 1
b = 0
a += 1
if a > 0:
su += a
if fl == 0:
buf1 = a
else:
buf = a
a = 0
if b > 0:
rs += 2 * (b - 1) + 1
b = 0
if su <= k or rs == n*2 - 1:
print(n*2 - 1)
else:
kek.sort()
#print(kek, cnt)
k1 = k
for el in kek:
if k1 >= el:
rs += el*2 + 1
k1 -= el
else:
rs += k1*2
k1 = 0
if k1 > 0 and buf < 1e10:
if k1 >= buf:
k1 -= buf
rs += buf * 2
else:
rs += k1 * 2
k1 = 0
if k1 > 0:
if k1 >= buf1:
k1 -= buf1
rs += buf1*2 - (not fl)
else:
rs += k1 * 2 - (not fl)
k1 = 0
print(rs)
#1
#5 4
#LLLLL
#1
#5 2
#LLWLL | 8 | PYTHON3 |
for _ in range(int(input())):
n,k = map(int,input().split())
ik = k
sg = input().strip()
gaps = []
l = len(sg)
wins = 0
win_streaks = 0
i = 0
lcnt = 0
temp = 0
while i < l:
if sg[i] == 'W':
break
i += 1
temp += 1
filled_gaps = 0
while i < l:
if sg[i] == 'W':
win_streaks += 1
while i < l and sg[i] == 'W':
wins += 1
i += 1
if i < l and sg[i] == 'L':
lcnt = 0
while i < l and sg[i] == 'L':
lcnt += 1
i += 1
else:
if i < l and sg[i] == 'W':
gaps.append(lcnt)
else:
temp += lcnt
gaps.sort()
gap_l = len(gaps)
j = 0
while k > 0 and j < gap_l:
if gaps[j] <= k:
k -= gaps[j]
filled_gaps += 1
j += 1
if k > 0 and temp > 0 and wins == 0:
win_streaks += 1
score = 2*(min(wins + ik , l)) - win_streaks + filled_gaps
print(score) | 8 | PYTHON3 |
for _ in range(int(input())):
n, k = [int(i) for i in input().split()]
s = input()
ws = s.count("W")
if k + ws >= n:
print(2*n-1)
elif k == 0 and ws==0:
print(0)
else:
chains = []
chain = 0
streak = False
for char in s.strip("L"):
if char == "W" and chain != 0:
chains.append(chain)
chain = 0
elif char == "L":
chain += 1
chains.sort()
i = 0
total = 0
while chains and total+chains[i] <= k:
total += chains[i]
i += 1
if i >= len(chains):
break
print(2*(k+ws)-len(chains)-1+i) | 8 | PYTHON3 |
#include <bits/stdc++.h>
template <class T>
inline void rd(T &x) {
char c = getchar(), f = 0;
x = 0;
while (!isdigit(c)) f = (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x = f ? -x : x;
}
const int MAXN = 2e5 + 7;
int n, k;
char s[MAXN];
void solve() {
rd(n);
rd(k);
scanf("%s", s + 1);
int ans = 0, c = 0;
for (int i = (1); i <= (n); ++i) ans += 2 * (s[i] == 'W'), c += s[i] == 'L';
int cc = 0;
std::vector<int> a;
k = std::min(k, c);
ans += k * 2;
for (int i = 1; i <= n;) {
int j = i;
while (s[i] == s[j] && j <= n) j++;
if (s[i] == 'L' && i != 1 && j != n + 1) a.push_back(j - i);
if (s[i] == 'W') cc++;
i = j;
}
if (!cc && k) cc++;
std::sort((a).begin(), (a).end());
for (auto v : a) {
if (k < v)
break;
else
k -= v, cc--;
}
printf("%d\n", ans - cc);
}
int main() {
int T;
rd(T);
while (T--) solve();
return 0;
}
| 8 | CPP |
import sys
input = sys.stdin.readline
'''
'''
def get_close(n, i, res):
while i < n and res[i] == "L":
i += 1
return i - 1
def calc(n, res):
count = 0
for i in range(n):
if i > 0 and res[i-1] == res[i] == "W":
count += 2
elif res[i] == "W":
count += 1
return count
def solve(n, k, res):
gaps = []
rem = []
i = 0
while i < n:
if res[i] == "L":
op, cl = i, get_close(n, i+1, res)
gaps.append((cl-op+1, op, cl))
i = cl + 1
if op == 0 or cl == n-1:
rem.append(gaps.pop())
else:
i += 1
gaps.sort()
for gap, start, stop in gaps:
if not k:
break
for i in range(start, stop+1):
if k:
res[i] = "W"
k -= 1
else:
break
for _, start, stop in rem:
if start == 0:
g = reversed(range(start, stop+1))
else:
g = range(start, stop+1)
for i in g:
if k:
res[i] = "W"
k -= 1
else:
break
return calc(n, res)
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
res = list(input().rstrip())
print(solve(n, k, res))
#print(res) | 8 | PYTHON3 |
from collections import deque
for _ in range(int(input())):
n,k=map(int,input().split())
initialK=k
s=input()
gaps=[]
gapLen=0
if s[0]=='L':
w=0
else:
w=1
for i in range(1,len(s)):
if s[i]=='W':
w+=1
if gapLen!=0:
gaps.append(gapLen)
gapLen=0
else:
if s[i-1]=='W':
gapLen=1
else:
if gapLen!=0:
gapLen+=1
if w+k>=n:
print(2*n-1)
continue
#print(gaps)
gaps=deque(sorted(gaps))
#print(gaps)
while len(gaps)>0 and k>=gaps[0]:
k-=gaps.popleft()
#print(k,w)
ans=2*(initialK+w)-1-len(gaps)
#print(ans,gaps)
print(max(0,ans))
| 8 | PYTHON3 |
from itertools import groupby
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
if k >= s.count('L'):
print(n * 2 - 1)
else:
s = s.strip("L")
group = []
for i, g in groupby(s):
if i == 'L':
group.append(len(list(g)))
group.sort()
i, m = 0, len(group)
r = k
while i < m and r >= group[i]:
r -= group[i]
i += 1
ans = (s.count('W') + k) * 2 - (m + 1 - i)
print(max(0, ans))
| 8 | PYTHON3 |
T = int(input())
for _ in range(T):
n, k = map(int, input().split())
s = input()
res = 0
gaps=[]
gap0=0
gap = 0
prev = False
f = True
for x in s:
if f:
if x == 'L':
gap0 += 1
else:
f = False
res = 1
prev = True
else:
if x == 'L':
gap += 1
prev = False
else:
res += 1
if prev:
res += 1
else:
gaps.append(gap)
gap = 0
prev = True
if prev:
gapN = 0
else:
gapN = gap
gaps.sort()
nn = len(gaps)
i = 0
while i < nn and k >= gaps[i]:
res += 2*gaps[i] + 1
k -= gaps[i]
i += 1
if i < nn or k <= gap0 + gap:
res += 2*k
else:
res += (gap0+gap)*2
if gap0 == n and k>0:
res -= 1
print(res)
| 8 | PYTHON3 |
t = int(input())
for i in range(t):
n,k = list(map(int,input().split()))
s = input()
suml = 0
score = 0
lstl = []
count = 0
for j in range(n):
if(j == 0 and s[0] == "W"):
score += 1
continue
elif(s[j] == "L"):
score += 0
elif(s[j] == "W" and s[j-1] == "W"):
score += 2
elif(s[j] == "W" and s[j-1] == "L"):
score += 1
##print("original" , score)
if( k == 0):
print(score)
continue
for j in range(n):
if(s[j] == "W" and count != 0):
lstl.append(count)
count = 0
elif(s[j]=="L"):
count += 1
if(count!=0):
lstl.append(count)
##print(lstl)
laststreak = 0
firststreak = 0
if(s[n-1] == "L"):
laststreak = lstl[-1]
if(s[0] == "L"):
firststreak = lstl[0]
for j in s:
if(j == "L"):
suml += 1
if(k >= suml):
print(1 + 2*(n-1))
continue
elif( suml == n):
print( 1 + (k-1)*2)
elif(k < suml):
if(s[0] == "W" and s[n-1] == "W"):
lstl.sort()
for q in range(len(lstl)):
if(k == 0):
break
if(k >=lstl[q]):
score += (2*(lstl[q]) + 1)
k = k - lstl[q]
else:
score += 2*(k)
k = 0
break
else:
if(s[0] == "W" and s[-1] == "L"):
lstl = lstl[0:len(lstl)-1]
lstl.sort()
elif(s[0] == "L" and s[-1] == "W"):
lstl = lstl[1:len(lstl)]
lstl.sort()
else:
lstl = lstl[1:len(lstl)-1]
lstl.sort()
for q in range(len(lstl)):
if(k == 0):
break
if(k >=lstl[q]):
score += (2*(lstl[q]) + 1)
k = k - lstl[q]
else:
score += 2*(k)
k = 0
break
h = laststreak + firststreak
if(k!=0 and k <= h):
score += k*2
print(score)
| 8 | PYTHON3 |
import sys
# from math import ceil
# For getting input f rom input.txt file
# sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
s=input()
i=0
l=[]
el=0
while(i<n and s[i]=="L"):
i+=1
el+=1
j=n-1
while(j>i and s[j]=="L"):
j-=1
el+=1
# print(i,j)
if i>j:
print(max(0,2*k-1))
continue
ans=0
while(i<=j):
c=0
while(i<=j and s[i]=="W"):
i+=1
c+=1
ans+=2*c-1
c=0
while(i<=j and s[i]=="L"):
i+=1
c+=1
if c!=0:
l.append(c)
l.sort()
i,le=0,len(l)
while(i<le and k>0):
if k>=l[i]:
ans+=(2*l[i]+1)
else:
ans+=(2*k)
k-=l[i]
i+=1
print(ans+2*max(0,min(k,el)))
| 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = [int(i) for i in input().split(" ")]
s = input()
a = []
cur = 0
flag = False
b = []
w = 0
for i in range(n):
if s[i] == "L":
cur += 1
else:
w += 1
if cur > 0:
a.append(cur)
cur = 0
if cur > 0:
a.append(cur)
k = min(k, n-w)
# print("k", k)
if s[0] == "W":
if s[-1] == "W":
b = a[:]
else:
b = a[:-1]
else:
if s[-1] == "W":
b = a[1:]
else:
b = a[1:-1]
# print(b)
b.sort()
score = 2*w - 1 - len(b)
if score < 0:
score = max(0,2*k-1)
print(score)
continue
# if s[-1] == "W":
# score -= 1
# print(k, b, score)
for i in b:
if k >= i:
k -= i
score += 2*i + 1
else:
break
score += 2*k
print(score) | 8 | PYTHON3 |
ins=input
for _ in [0]*int(ins()):
n, k = map(int, ins().split())
s = ins()
c = s.count('W')
n = min(n, c+k)
a = sorted(map(len, filter(None, s.strip('L').split('W'))))
while a and c+a[0] <= n:
c += a.pop(0)
print((2 * n - len(a) or 1) - 1)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
s=list(input())
if "W" not in s:
print(max((min(n,k)*2)-1,0))
elif k>=s.count("L"):
print((2*n)-1)
else:
cnt,sm,ind=list(),s.count("W"),s.index("W")
for i in range(ind+1,n):
if s[i] == "W":
cnt.append(i-ind-1)
ind=i
cnt.sort()
for i in cnt:
if k >= i:
sm+=(2*i)+1
k-=i
if k>0:
sm+=(2*k)
print(sm)
| 8 | PYTHON3 |
import heapq
def solve(st, n, k):
prev = 'L'
c, bug = 0, k
li = []
score = 0
count_l = st.count('L')
if count_l == n:
return max(2*min(k, n) - 1, 0)
for it in st:
if it == prev:
if it=='W':
score+=2
c+=1
else:
if it=='W':
score+=1
li.append(c)
c = 1
prev = it
if c:
li.append(c)
hl = []
heapq.heapify(hl)
ln = len(li)
i = 2
while i+1<ln:
it = li[i]
heapq.heappush(hl, it)
i+=2
while hl:
tp = heapq.heappop(hl)
if tp <= bug:
bug -= tp
count_l -= tp
score += 2*tp + 1
cngo = min(bug, count_l)
score += 2*cngo
return score
for case in range(int(input())):
n, k = map(int, input().split())
st = input()
ans = solve(st, n, k)
print(ans)
| 8 | PYTHON3 |
##############--->>>>> Deepcoder Amit Kumar Bhuyan <<<<<---##############
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
import sys
input = sys.stdin.readline
scanner = lambda: int(input())
string = lambda: input().rstrip()
get_list = lambda: list(read())
read = lambda: map(int, input().split())
get_float = lambda: map(float, input().split())
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
def fact(x):
val = 1
while x > 0:
val *= x
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## lcm function
def lcm(a, b):
return (a * b) // math.gcd(a, b)
def is_integer(n):
return math.ceil(n) == math.floor(n)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if k > n:
return 0
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
if y == 0:
return 1
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
prime[0], prime[1] = False, False
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
# Euler's Toitent Function phi
def phi(n) :
result = n
p = 2
while(p * p<= n) :
if (n % p == 0) :
while (n % p == 0) :
n = n // p
result = result * (1.0 - (1.0 / (float) (p)))
p = p + 1
if (n > 1) :
result = result * (1.0 - (1.0 / (float)(n)))
return (int)(result)
def is_prime(n):
if n == 0:
return False
if n == 1:
return True
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def next_prime(n, primes):
while primes[n] != True:
n += 1
return n
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
res = []
for i in range(2, int(x ** 0.5) + 1):
while x % i == 0:
res.append(i)
x //= i
if x != 1:
res.append(x)
return res
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
def factors(n):
res = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
res.append(n // i)
return list(set(res))
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
def binary_search(low, high, w, h, n):
while low < high:
mid = low + (high - low) // 2
# print(low, mid, high)
if check(mid, w, h, n):
low = mid + 1
else:
high = mid
return low
## for checking any conditions
def check(moves, n):
val = (moves + 1) // 2
rem = moves - val
sol = (val + 1) * (rem + 1)
return sol < n
## for sorting according to second position
def sortSecond(val):
return val[1]
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
alphs = "abcdefghijklmnopqrstuvwxyz"
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect
import functools as fnt
from decimal import Decimal
# from sys import stdout
# import numpy as np
"""
_______________
rough work here
_______________
001110001
"""
def solve():
n, k = read()
tournaments = list(string())
start = 0
end = n - 1
z = k
while start < n and tournaments[start] != "W":
start += 1
while end >= 0 and tournaments[end] != "W":
end -= 1
lstart = INF
lend = 0
c = 0
lengths = []
countw = tournaments.count("W")
countl = 0
# print(start, end)
winning_streak = 0
for i in range(start, end + 1):
if tournaments[i] == "L":
lstart = min(lstart, i)
c += 1
countl += 1
else:
lend = i
if c > 0:
winning_streak += 1
lengths.append(c)
c = 0
lstart = INF
lengths.sort()
winning_streak += 1
# print(lengths, countl, winning_streak)
gaps = 0
c = 0
for x in lengths:
if c > k:
break
gaps += 1
c += x
if c > k:
gaps -= 1
# print(countw, winning_streak, gaps)
print(max(0, 2 * min(countw + k, n) - winning_streak + gaps))
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
t = scanner()
for i in range(t):
solve()
#dmain()
# Comment Read()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
| 8 | PYTHON3 |
t=int(input())
def func(arr,n):
start=None;end=None
for i in range(n):
if arr[i]=="W":
start=i
break
for i in reversed(range(n)):
if arr[i]=="W":
end=i
break
return start,end
while t>0:
t-=1
n,k=list(map(int,input().split()))
arr=input()
start,end=func(arr,n)
dict={}
streak=0;point=0
if start!=None and end!=None:
for i in range(start,end+1):
if arr[i]=="L":
streak+=1
if arr[i+1]!="L":
if streak in dict:
dict[streak]+=1
else:dict[streak]=1
streak=0
else:
if i!=start:
if arr[i-1]=="W":point+=2
else:point+=1
else:point+=1
for score in sorted(dict):
if k>0:
if k>=score*dict[score]:
k-=score*dict[score]
point+=score*dict[score]*2+dict[score]
else:
point+=k*2
point+=k//score
k=0
else:
break
if start==None: left=n
else: left=start+(n-end-1)
if k>0:
if start!=None:
if k>=left:point+=left*2 ;k-=left
else:point+=k*2 ;k-=k
else:
if k>=left:point+=left*2-1 ;k-=left
else:point+=k*2-1 ;k-=k
print(point)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <typename T>
void read(vector<T>& arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < N; i++) cin >> arr[i];
}
template <typename T>
void read(vector<pair<T, T>>& arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < (long long)arr.size(); i++)
cin >> arr[i].first >> arr[i].second;
}
template <typename T>
void read(vector<vector<T>>& arr, long long N, long long M) {
arr.clear();
arr.resize(N, vector<T>(M));
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) cin >> arr[i][j];
}
}
template <typename T>
void print(vector<T>& arr) {
for (auto it : arr) cout << it << ' ';
cout << '\n';
}
template <typename T>
void print(vector<pair<T, T>>& arr) {
for (auto it : arr) cout << " { " << it.first << ',' << it.second << " } ";
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& arr) {
for (auto it : arr) {
for (auto ut : it) cout << ut << ' ';
cout << '\n';
}
cout << '\n';
}
template <typename T>
void print(list<T>& arr) {
for (auto it = (arr).begin(); it != (arr).end(); it++) cout << *it << ' ';
cout << '\n';
}
template <typename T>
void print(unordered_set<T>& ss) {
for (auto it = (ss).begin(); it != (ss).end(); it++) cout << *it << ' ';
cout << '\n';
}
template <typename T>
void print(set<T>& ss) {
for (auto it = (ss).begin(); it != (ss).end(); it++) cout << *it << ' ';
cout << '\n';
}
bool lexi(string& s1, string& s2) {
long long I = s1.size(), J = s2.size(), i = 0, j = 0;
while (i < I and j < J) {
if (s1[i] > s2[j]) return true;
if (s1[i] < s2[j]) return false;
i++;
j++;
}
if (I >= J) return true;
return false;
}
struct uf {
vector<long long> par, size;
void init(long long N) {
par.resize(N, -1);
size.resize(N, 1);
}
long long root(long long a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(long long a, long long b) {
a = root(a);
b = root(b);
if (a == b) return;
if (size[a] < size[b]) {
par[a] = b;
size[b] += size[a];
} else {
par[b] = a;
size[a] += size[b];
}
}
bool same(long long a, long long b) {
if (root(a) == root(b)) return true;
return false;
}
};
struct seg_tree {
vector<long long> make;
long long siz;
vector<long long> arr;
void init(vector<long long>& a, bool max, bool range) {
arr.clear();
make.clear();
arr = a;
siz = arr.size();
make.resize(4 * siz);
if (max)
build_max(0, 0, siz - 1);
else if (range)
build_range(0, 0, siz - 1);
}
long long get_max(long long L, long long R) {
return Get_max(0, 0, siz - 1, L, R);
}
void update_max(long long index, long long val) {
Update_max(0, 0, siz - 1, index, val);
return;
}
long long get_sum(long long L, long long R) {
return Get_sum(0, 0, siz - 1, L, R);
}
void update_range(long long index, long long add) {
Update_range(0, 0, siz - 1, index, add);
return;
}
long long build_range(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
long long a = build_range(2 * ind + 1, L, mid);
long long b = build_range(2 * ind + 2, mid + 1, R);
make[ind] = a + b;
return make[ind];
}
}
long long Get_sum(long long ind, long long L, long long R, long long Left,
long long Right) {
if (L > Right or R < Left) return 0;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
long long a = Get_sum(2 * ind + 1, L, mid, Left, Right);
long long b = Get_sum(2 * ind + 2, mid + 1, R, Left, Right);
return a + b;
}
void Update_range(long long ind, long long L, long long R, long long index,
long long add) {
if (L == R) {
make[ind] += add;
arr[index] += add;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= R) {
Update_range(2 * ind + 1, L, mid, index, add);
} else {
Update_range(2 * ind + 2, mid + 1, R, index, add);
}
make[ind] = make[2 * ind + 1] + make[2 * ind + 2];
}
}
long long build_max(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
return make[ind] = max(build_max(2 * ind + 1, L, mid),
build_max(2 * ind + 2, mid + 1, R));
}
}
long long Get_max(long long ind, long long L, long long R, long long Left,
long long Right) {
if (R < Left or L > Right) return -1e15;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
return max(Get_max(2 * ind + 1, L, mid, Left, Right),
Get_max(2 * ind + 2, mid + 1, R, Left, Right));
}
long long Update_max(long long ind, long long L, long long R, long long index,
long long val) {
if (L == R) {
arr[index] = val;
make[ind] = val;
return val;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= mid) {
make[ind] = Update_max(2 * ind + 1, L, mid, index, val);
} else {
make[ind] = Update_max(2 * ind + 2, mid + 1, R, index, val);
}
make[ind] = max(make[2 * ind + 1], make[2 * ind + 2]);
return make[ind];
}
}
};
static bool comp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.first < b.first) return true;
if (a.first == b.first) {
if (a.second < b.second) return true;
}
return false;
}
long long Max = 1e17, Min = -1e16;
long long N, M, K, D;
long long mod = 1e9 + 7;
string st;
static bool comp1(pair<long long, long long>& a,
pair<long long, long long>& b) {
if (a.second - a.first < b.second - b.first) return true;
return false;
}
void solve() {
cin >> N >> K;
cin >> st;
vector<long long> win;
for (long long i = 0; i < N; i++) {
if (st[i] == 'W') win.push_back(i);
}
vector<pair<long long, long long>> arr;
for (long long i = 0; i < (long long)win.size() - 1; i++) {
arr.emplace_back(win[i], win[i + 1]);
}
sort(arr.begin(), arr.end(), comp1);
for (long long i = 0; i < (long long)arr.size(); i++) {
for (long long j = arr[i].first + 1; j < arr[i].second and K > 0; j++) {
st[j] = 'W';
K--;
}
}
if (win.empty() == false) {
for (long long i = win[0] - 1; i >= 0 and K > 0; i--) {
st[i] = 'W';
K--;
}
}
if (win.size() >= 2) {
for (long long i = win.back() + 1; i < N and K > 0; i++) {
st[i] = 'W';
K--;
}
}
for (long long i = 0; i < N and K > 0; i++) {
if (st[i] != 'W') {
st[i] = 'W';
K--;
}
}
long long cnt = 0;
for (long long i = 0; i < N; i++) {
if (st[i] == 'W') {
if (i - 1 >= 0 and st[i - 1] == 'W')
cnt += 2;
else
cnt += 1;
}
}
cout << cnt << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start_time = chrono::high_resolution_clock::now();
bool test = 1;
if (!test)
solve();
else {
long long tt;
cin >> tt;
while (tt--) solve();
}
auto end_time = chrono::high_resolution_clock::now();
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n,k = list(map(int,input().split()))
s = input()
if "W" not in s: # pure losses case discarded
print(max(min(n,k)*2-1,0))
continue
l = s.split("W")[1:-1] # Lengths of blocks of L's except first and last block
l = list(filter(None,l))
l = [len(block) for block in l]
l.sort()
ncut = len(l)+1
x = s.count("W")
for i in range(len(l)):
if k >= l[i]:
x += l[i]
k -= l[i]
ncut-=1
print(max(0,min(2*n-1,(x+k)*2-ncut))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
bool operator<(const P &a) const { return y > a.y; };
};
int a, b, c, d, i, n, m, e, k, dx[10] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[10] = {0, 1, 0, -1, 1, -1, 1, -1};
int o[111];
int l[1];
int ss[1];
long long x, y, z, mod = 1000000007, hf = (mod + 1) / 2;
char r[101111];
vector<int> v[1];
P u[1];
priority_queue<int, vector<int>, greater<int> > q;
set<int> s[1];
map<int, int> p;
bool as(P a, P b) { return a.y < b.y; }
int main() {
int ttt;
scanf("%d", &ttt);
for (int tt = 1; tt <= ttt; tt++) {
scanf("%d %d", &a, &b);
scanf("%s", r + 1);
k = 0;
priority_queue<int, vector<int>, greater<int> > q;
e = 0;
m = 0;
for (int t = 1; t <= a; t++) {
if (r[t] == 'W') {
k += 2;
if (e) {
k--;
if (e + 1 != t) q.push(e);
} else if (t == 1)
k--;
e = 0;
} else
e++;
}
n = 0;
m = a + 1;
for (int t = 1; t <= a; t++)
if (r[t] == 'L')
n = t;
else
break;
for (int t = a; t; t--)
if (r[t] == 'L')
m = t;
else
break;
if (1 == m && n == a)
m = 0;
else
m = a - m + 1;
if (n + m == a) {
printf("%d\n", max(min(a, b) * 2 - 1, 0));
continue;
}
for (; b && q.size(); q.pop()) {
if (b >= q.top()) {
k++;
k += q.top() * 2;
b -= q.top();
} else {
k += b * 2;
b = 0;
}
}
k += min(b, n + m) * 2;
printf("%d\n", k);
}
}
| 8 | CPP |
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n,k = map(int,input().split())
s = input()
s = [s[i] for i in range(n)]
base = s.count("W")
if base == 0:
if k:
print(2*k-1)
else:
print(0)
elif base+k>=n:
print(2*n-1)
else:
interval = []
while s and s[-1]=="L":
s.pop()
s = s[::-1]
while s and s[-1]=="L":
s.pop()
while s:
if s[-1]=="W":
while s and s[-1]=="W":
s.pop()
else:
tmp = 0
while s and s[-1]=="L":
s.pop()
tmp += 1
interval.append(tmp)
interval.sort(reverse=True)
K = k
while interval and k:
if k>=interval[-1]:
k -= interval.pop()
else:
break
print(2*(base+K)-1-len(interval)) | 8 | PYTHON3 |
for inx in range(int(input())):
n,k = map(int,input().split());l = input();b=sc=0;g=[];p='L'
for c in l:
if c=='W':
sc = (sc + 2 if p=='W' else sc + 1);p='W'
if b:g.append(b)
b=0
else:p='L';b+=1
if b:g.append(b)
cbg=cen=0
if l[0]=='L':cbg=g.pop(0)
if l[-1]=='L':
if sc:cen=g.pop()
g.sort()
while k and g:
b=g.pop(0)
if k>=b:k-=b;sc+=2*b+1
else:sc+=2*k;k=0
if k:sc = (sc + 2*min(k,cbg+cen) if sc else sc + 2*min(k,cbg)-1)
print(sc) | 8 | PYTHON3 |
t = int(input())
def solve(s, k):
gaps = []
last_pos = None
if s.count('L') == len(s):
if k:
return k * 2 - 1
else:
return 0
for i, x in enumerate(s):
if x == 'W':
if last_pos is not None:
gaps.append((i - last_pos - 1, last_pos + 1, i))
last_pos = i
gaps.sort(reverse=True)
#print(gaps)
score = 0
while gaps and k:
width, start, end = gaps.pop()
if width <= k and width:
score += 1
k -= width
score += width * 2
if k:
#print("Increasing score since have some moves left over...", score, score + 2 * k)
# There are no big enough gaps
# means that on both sides there are
# enough Ls to do the flop
score += 2 * k
return score
for case in range(t):
n, k = map(int, input().split())
s = input()
k = min(k, s.count('L')) # changing W to L always bad
# Compute initial score
score = 0
for i, x in enumerate(s):
score += x == 'W'
if x == 'W' and i > 0:
score += s[i-1] == 'W'
print(score + solve(s, k))
| 8 | PYTHON3 |
from sys import stdin, stdout
import math
import heapq
import collections
input = stdin.readline
def inputnum():
return(int(input()))
def inputnums():
return(map(int,input().split()))
def inputlist():
return(list(map(int,input().split())))
def inputstring():
return([x for x in input()])
def inputstrings():
return([x for x in input().split()])
def inputstringnum():
return([ord(x)-ord('a') for x in input()])
def inputmatrixchar(rows):
arr2d = [[j for j in input().strip()] for i in range(rows)]
return arr2d
def inputmatrixint(rows):
arr2d = []
for _ in range(rows):
arr2d.append([int(i) for i in input().split()])
return arr2d
t = int(input())
for q in range(t):
n, k = inputnums()
s = inputstring()
losingstreak = []
winningstreak = 0
wins = 0
losses = 0
curloss = 0
for i in range(n):
if s[i] == 'W':
wins += 1
if i == 0 or s[i-1] == 'L':
winningstreak += 1
else:
losses += 1
curloss += 1
if i == n-1 or s[i+1] == 'W':
losingstreak.append(curloss)
curloss = 0
if k >= losses:
print(2*n-1)
continue
if wins == 0:
if k == 0:
print(0)
continue
else:
print(2*k-1)
continue
if s[0] == 'L':
losingstreak[0] = 1e9
if s[n-1] == 'L':
losingstreak[len(losingstreak)-1] = 1e9
losingstreak.sort()
wins += k
for i in range(len(losingstreak)):
if k < losingstreak[i]:
break
else:
winningstreak -= 1
k -= losingstreak[i]
print(2*wins - winningstreak) | 8 | PYTHON3 |
import collections
def readis():
return map(int, input().strip().split())
def printlist(xs):
print(" ".join(map(str, xs)))
T = int(input())
while T:
T -= 1
n, k = readis()
s = input()
cs = list(s)
loss_start = -1
loss_conts = []
l_beg = 0
l_end = 0
score = 0
for i, c in enumerate(s):
if c == "W":
score += 1 + int(i > 0 and s[i-1] == "W")
if set(s) == {"L"}:
n_reverts = min(len(s), k)
inc = 2 * n_reverts - 1 if n_reverts else 0
print(score + inc)
continue
if set(s) == {"W"}:
print(score)
continue
for i, c in enumerate(s):
if loss_start > -1:
if c == "W":
if loss_start == 0:
l_beg = i
else:
loss_conts.append(i - loss_start)
loss_start = -1
else:
if c == "L":
loss_start = i
if loss_start > -1:
l_end = n - loss_start
max_score = score
for cont in sorted(loss_conts):
if k > 0:
n_cheats = min(k, cont)
k -= n_cheats
max_score += 2 * n_cheats + int(n_cheats == cont)
else:
break
if k > 0 and l_end:
n_cheats = min(k, l_end)
k -= n_cheats
max_score += 2 * n_cheats
if k > 0 and l_beg:
n_cheats = min(k, l_beg)
k -= n_cheats
max_score += 2 * n_cheats
print(max_score)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i, ans = -23, k, res = 0;
vector<long long int> v;
cin >> n >> k;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (i == 0) {
if (s[i] == 'W') {
ans = i;
res++;
}
} else if (i > 0) {
if (s[i] == 'W' && s[i - 1] == 'W') {
res += 2;
ans = i;
} else if (s[i] == 'W') {
res++;
ans = i;
}
}
}
for (i = 0; i < ans; i++) {
if (s[i] == 'W') break;
}
long long int x = i;
long long int y = x;
x = 0;
for (i = y + 1; i < ans; i++) {
if (s[i] == 'L')
x++;
else {
if (x != 0) v.push_back(x);
x = 0;
}
}
if (x != 0) v.push_back(x);
if (v.size() != 0) {
sort(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
if (k <= 0) break;
if (v[i] <= k)
res += (2 * v[i]) + 1;
else if (v[i] > k)
res += (2 * k);
k -= v[i];
if (k <= 0) break;
}
}
if (k > 0) {
if (ans < 0)
res += min(k, n) * 2 - 1;
else {
res += min(k, n - ans - 1) * 2;
k -= (n - ans - 1);
if (k > 0) {
res += (min(y, k) * 2);
}
}
}
printf("%lld\n", res);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int dx[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dy[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int MOD = 998244353, N = 2e5 + 5, oo = 1e9;
const double pi = acos(-1);
using namespace std;
int n, k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
bool other = false;
cin >> n >> k;
string s;
cin >> s;
vector<int> vec;
int cnt = 0;
for (int i = (int)(s).size() - 1; i >= 0; i--) {
if (s[i] == 'L')
cnt++;
else {
other = 1;
vec.push_back(cnt);
cnt = 0;
}
}
int start = 0, end = 0;
if (cnt) vec.push_back(cnt);
if (s[0] == 'L') start = vec.back(), vec.pop_back();
if (s[(int)(s).size() - 1] == 'L' and (int)(vec).size())
end = vec[0], vec[0] = 0;
sort(vec.begin(), vec.end());
long long ans = 0;
for (int i = 0; i < (int)(s).size(); i++)
if (s[i] == 'W') ans += (i and s[i - 1] == 'W') ? 2 : 1;
for (auto it : vec) {
if (!k) break;
if (it) {
if (k >= it)
ans += it * 2, ans++;
else
ans += k * 2;
k -= min(k, it);
}
}
if (k and end) {
ans += 2 * min(k, end);
k -= min(k, end);
}
if (k and start) {
if (k >= start) {
ans++, k--;
ans += 2 * min(k, start - 1);
if (other and k >= start - 1) ans++;
} else if (other)
ans += 2 * k;
else
ans += 2 * (k - 1), ans++;
}
cout << ans << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cnt = 0;
for (char c : s)
if (c == 'L') cnt++;
if (cnt == n) {
cout << max(0, 2 * k - 1) << "\n";
continue;
}
k = min(k, cnt);
int ans = 0;
bool w = false;
vector<int> X;
cnt = 0;
for (int i = 0; i < n; i++) {
char c = s[i];
if (c == 'L') {
cnt++;
if (i + 1 == n || s[i + 1] == 'W') {
if (cnt == i + 1 || i == n - 1)
X.push_back(n + 1);
else
X.push_back(cnt);
}
w = false;
} else {
cnt = 0;
if (w)
ans += 2;
else
ans++;
w = true;
}
}
int dar = 0;
sort(X.begin(), X.end());
for (int i : X) {
if (k > 0) {
if (k >= i) {
ans += 2 * i + 1;
k -= i;
} else {
ans += 2 * k;
break;
}
}
}
cout << ans + dar << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
deque<int> dq;
string s;
cin >> s;
long long wins = 0, loses = 0;
int w_streak = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
loses++;
}
if (s[i] == 'W') {
wins++;
if (i == 0 || s[i - 1] == 'L') w_streak++;
}
}
if (loses <= k) {
cout << 2 * n - 1 << "\n";
return;
}
int i = 0;
while (i < n) {
if (s[i] == 'L') {
int l = 0;
while (s[i] == 'L' && i < n) {
l++;
i++;
}
dq.push_back(l);
} else
i++;
}
int starting_loses = 0, ending_loses = 0;
if (s[0] == 'L') {
starting_loses = dq[0];
dq.pop_front();
}
if (s[n - 1] == 'L' && w_streak) {
ending_loses = dq[dq.size() - 1];
dq.pop_back();
}
vector<int> v;
for (auto x : dq) v.push_back(x);
sort(v.begin(), v.end());
for (auto x : v) {
if (x <= k) {
k -= x;
w_streak -= 1;
wins += x;
} else {
wins += k;
k = 0;
}
}
if (loses == n && k > 0) w_streak++;
if (k) wins += k;
cout << 2 * wins - w_streak << "\n";
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 8 | CPP |
for _ in " "*int(input()):
n,k=map(int,input().split())
s=list(input())
if "W" not in s:
print(max((min(k,n)*2)-1,0))
elif k >= s.count("L"):
print((n*2)-1)
else:
cnt,sm,ind=list(),s.count("W"),s.index("W")
for i in range(ind+1,n):
if s[i] == "W":
cnt.append(i-ind-1)
ind=i
cnt.sort()
for i in cnt:
if k >= i:
sm+=(2*i)+1
k-=i
if k>0:
sm+=(2*k)
print(sm) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double PI = acos(-1.0);
const double epsilon = PI / 180.0;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 1e5 + 10, M = 1e6 + 10;
struct node {
int l, r;
int len;
} a[N];
bool cmp(node a, node b) { return a.len < b.len; }
int n, k;
string s;
vector<int> v;
int main() {
int _;
cin >> _;
while (_--) {
v.clear();
cin >> n >> k;
cin >> s;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
v.push_back(i);
if (i - 1 >= 0 && s[i - 1] == 'W')
ans += 2;
else
ans++;
}
}
if (v.size() == 0) {
if (k == 0)
cout << "0\n";
else
cout << 1 + (k - 1) * 2 << "\n";
continue;
}
int m = v.size() - 1;
for (int i = 0; i < m; i++) {
a[i] = {v[i], v[i + 1], v[i + 1] - v[i] - 1};
}
sort(a, a + m, cmp);
for (int i = 0; i < m; i++) {
if (k == 0) break;
int tmp = min(k, a[i].len);
if (tmp > 0 && tmp == a[i].len)
ans += (tmp - 1) * 2 + 3;
else
ans += tmp * 2;
k -= tmp;
}
if (k != 0) {
int tmp = min(k, v[0] + n - 1 - v[m]);
ans += tmp * 2;
}
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
from __future__ import division, print_function
import bisect
import math
import heapq
import itertools
import sys
from collections import deque
from atexit import register
from collections import Counter
from functools import reduce
if sys.version_info[0] < 3:
from io import BytesIO as stream
else:
from io import StringIO as stream
if sys.version_info[0] < 3:
class dict(dict):
"""dict() -> new empty dictionary"""
def items(self):
"""D.items() -> a set-like object providing a view on D's items"""
return dict.iteritems(self)
def keys(self):
"""D.keys() -> a set-like object providing a view on D's keys"""
return dict.iterkeys(self)
def values(self):
"""D.values() -> an object providing a view on D's values"""
return dict.itervalues(self)
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def sync_with_stdio(sync=True):
"""Set whether the standard Python streams are allowed to buffer their I/O.
Args:
sync (bool, optional): The new synchronization setting.
"""
global input, flush
if sync:
flush = sys.stdout.flush
else:
sys.stdin = stream(sys.stdin.read())
input = lambda: sys.stdin.readline().rstrip('\r\n')
sys.stdout = stream()
register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
def main():
# sys.stdin = open("input.txt")
for _ in range(int(input())):
n,k=map(int,input().split())
s=input()
cnt=s.count("L")
if k>=cnt:
print(2*(n-1)+1)
else:
i=0
while i<n and s[i]=="L":
i+=1
if i==n:
if k==0:
print("0")
continue
else:
print(2*(k-1)+1)
continue
su=1
a=i
v=[]
for j in range(a+1,n):
if s[j]=="W":
if a+1==j:
su+=2
else:
su+=1
v.append(j-a-1)
a=j
v.sort()
for i in v:
if i>k:
break
cnt-=i
k-=i
su+=(2*i+1)
if k:
su+=2*(min(k,cnt))
print(su)
if __name__ == '__main__':
sync_with_stdio(False)
main() | 8 | PYTHON3 |
for t in range(int(input())):
n,k=map(int,input().split())
s=input()
if k>=n:
print(n*2-1)
continue
l=0
inter=[]
count=0
out=0
for i in s:
if i=='L':
l+=1
count+=1
else:
if count!=0:
inter.append(count)
out+=1
else:
out+=2
count=0
if s[0]=='W':
out-=1
elif inter:
inter.pop(0)
if l<=k:
print(n*2-1)
elif l==n and k!=0:
print(k*2-1)
else:
r=n-l
inter.sort()
for i in inter:
if k>=i:
out+=i*2+1
k-=i
else:
out+=k*2
k=0
break
out+=k*2
print(out) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cntL = count(s.begin(), s.end(), 'L');
if (cntL == n) {
cout << max(2 * k - 1, 0) << "\n";
continue;
}
vector<int> posW;
for (int i = 0; i < n; i++)
if (s[i] == 'W') posW.push_back(i);
vector<int> seg;
for (int i = 1; i < int(posW.size()); i++)
if (posW[i] - posW[i - 1] - 1 > 0)
seg.push_back(posW[i] - posW[i - 1] - 1);
int ans = s[0] == 'W';
for (int i = 1; i < n; i++)
if (s[i] == 'W') ans += s[i - 1] == 'W' ? 2 : 1;
ans += 2 * min(k, cntL);
sort(seg.begin(), seg.end());
for (auto len : seg)
if (k >= len) k -= len, ans += 1;
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const char ln = '\n';
const char sp = ' ';
const long long mod = 1000000007;
long long modpow(long long x, long long y, long long p);
long long modinv(long long a, long long m);
long long lcm(long long a, long long b);
long long gcd(long long a, long long b);
bool po2(long long x);
struct comp;
void solve() {
long long n, k, l, ans = 0;
cin >> n >> k;
string s;
cin >> s;
bool flag = 1;
for (long long i = 1; i < n; ++i) {
if (s[i] != s[i - 1]) flag = 0;
}
if (flag) {
if (s[0] == 'W') {
ans += (s[0] == 'W' ? 1 : 0);
for (long long i = 1; i < n; ++i) {
if (s[i - 1] == 'W' && s[i] == 'W') {
ans += 2;
} else if (s[i] == 'W') {
ans += 1;
}
}
cout << ans << ln;
return;
} else {
ans = min(k, n) * 2 - 1;
cout << (k != 0 ? ans : 0) << ln;
return;
}
}
vector<long long> full;
bool w = 0;
long long beg = 0, end = 0;
for (long long i = 0; i < n; ++i) {
if (w == 0) {
while (i < n && s[i] == 'L') {
beg++;
i++;
}
if (i == n) {
end = beg;
break;
} else {
w = 1;
i--;
continue;
}
}
l = 0;
if (s[i] == 'L') {
while (i < n && s[i] == 'L') {
l++;
i++;
}
if (i == n) {
end = l;
} else {
full.push_back(l);
}
}
}
sort(full.begin(), full.end());
long long ii = 0;
while (k > 0) {
if (ii == full.size()) {
ans += min(k, end + beg) * 2;
break;
}
if (k >= full[ii]) {
k -= full[ii];
ans += 2 * full[ii] + 1;
ii++;
} else {
if (ii != full.size() || end != 0 || beg != 0) {
long long h = 0;
h += end + beg;
for (long long i = 0; i < full.size(); ++i) {
h += full[i];
}
h = min(h, k);
ans += 2 * h;
break;
}
}
}
ks:
ans += (s[0] == 'W' ? 1 : 0);
for (long long i = 1; i < n; ++i) {
if (s[i - 1] == 'W' && s[i] == 'W') {
ans += 2;
} else if (s[i] == 'W') {
ans += 1;
}
}
cout << ans << ln;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool po2(long long x) { return x && (!(x & (x - 1))); }
long long modpow(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modinv(long long a, long long m) {
long long g = gcd(a, m);
if (g != 1)
return -1;
else {
return modpow(a, m - 2, m);
}
}
struct comp {
bool operator()(pair<long long, long long> const& p1,
pair<long long, long long> const& p2) {
if (p1.first > p2.first)
return true;
else if (p1.first < p2.first)
return false;
else
return p1.second > p2.second;
}
};
| 8 | CPP |
t = int(input())
ans = [0 for _ in range(t)]
def score(s):
ret = 0
n = len(s)
for i in range(n):
if s[i] == "W":
if i == 0 or s[i - 1] == "L":
ret += 1
else:
ret += 2
return ret
for i in range(t):
n, k = map(int, input().split())
s = input()
if set(s) == set("W"):
ans[i] = 2 * n - 1
continue
if set(s) == set("L"):
ans[i] = max(2 * min(n, k) - 1, 0)
continue
left_gap = 0
right_gap = 0
gap = 0
gaps = []
for j in range(n):
if s[j] == "W":
if j > 0 and s[j - 1] == "L":
if j == gap:
left_gap = gap
else:
gaps.append(gap)
gap = 0
continue
gap += 1
if gap > 0:
right_gap = gap
a = score(s)
gaps.sort()
for g in gaps:
if k >= g:
a += 2 * g + 1
k -= g
continue
if k > 0:
a += 2 * k
k = 0
# if i == 1:
# print("i = 1", left_gap, right_gap, gaps, a)
cnt = 0
while k > 0:
if left_gap > 0:
a += 2 * min(left_gap, k)
k -= min(left_gap, k)
cnt += 1
# assert cnt == 1
# if i == 1:
# assert a == 9, "error i = 1, a = {}".format(a)
left_gap = 0
continue
if right_gap > 0:
a += 2 * min(right_gap, k)
k -= min(right_gap, k)
right_gap = 0
continue
break
ans[i] = a
for x in ans:
print(x)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238462643383;
const long long INF = 1e9 + 7;
const long long mod = 998244353;
int getID(char c) {
if (c == ' ') return 0;
return c - 'a' + 1;
}
long long pw(long long a, long long b) {
long long res = 1ll;
while (b) {
if (b & 1ll) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
void solve() {
int n, k, pos = 0;
cin >> n >> k;
string s;
cin >> s;
map<int, vector<int> > mp;
map<int, vector<int> >::iterator it;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
int j = i + 1;
while (j < n && s[j] == 'L') j++;
if (j == n) {
pos = i + 1;
break;
}
mp[j - i - 1].push_back(i + 1);
i = j - 1;
}
}
for (it = mp.begin(); it != mp.end(); it++) {
vector<int> a = it->second;
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < it->first; j++) {
if (k <= 0) break;
s[a[i] + j] = 'W';
k--;
}
if (k <= 0) break;
}
if (k <= 0) break;
}
while (pos < n && k > 0) s[pos++] = 'W', k--;
pos = n;
for (int i = 0; i < n; i++)
if (s[i] == 'W') {
pos = i;
break;
}
pos--;
while (pos >= 0 && k > 0) s[pos--] = 'W', k--;
int ct = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
int j = i + 1;
while (j < n && s[j] == 'W') j++;
ct += 1 + (j - i - 1) * 2;
i = j - 1;
}
}
cout << ct << "\n";
mp.clear();
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n,k = map(int,input().split())
s = list(input())
if "W" not in s:
print(max((min(k,n)*2)-1,0))
elif k>=s.count("L"):
print((n*2)-1)
else:
cnt = []
sm = s.count("W")
ind = s.index("W")
for i in range(ind+1,n):
if s[i]=="W":
cnt.append(i-ind-1)
ind = i
cnt.sort()
for i in cnt:
if k>=i:
sm+= (2*i)+1
k-=i
if k>0:
sm+=(2*k)
print(sm)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
namespace hash_tuple {
template <typename TT>
struct hash {
size_t operator()(TT const &tt) const { return std::hash<TT>()(tt); }
};
template <class T>
inline void hash_combine(std::size_t &seed, T const &v) {
seed ^= hash_tuple::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
void operator()(size_t &seed, Tuple const &tuple) const {
HashValueImpl<Tuple, Index - 1>{}(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple>
struct HashValueImpl<Tuple, 0> {
void operator()(size_t &seed, Tuple const &tuple) const {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT>
struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>{}(seed, tt);
return seed;
}
};
template <typename T>
inline void hash_val(std::size_t &seed, const T &val) {
hash_combine(seed, val);
}
template <typename T, typename... Types>
inline void hash_val(std::size_t &seed, const T &val, const Types &...args) {
hash_combine(seed, val);
hash_val(seed, args...);
}
template <typename... Types>
inline std::size_t hash_val(const Types &...args) {
std::size_t seed = 0;
hash_val(seed, args...);
return seed;
}
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2> &p) const {
return hash_val(p.first, p.second);
}
};
} // namespace hash_tuple
using namespace std;
int main() {
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int count = 0;
int wins = 0;
int losses = 0;
vector<int> losing_streaks;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
wins++;
count++;
if (i != 0 && s[i - 1] == 'W') count++;
}
if (s[i] == 'L') {
losses++;
if (i == 0 || s[i - 1] == 'W') losing_streaks.push_back(0);
losing_streaks.back()++;
}
}
if (k >= losses) {
cout << 2 * n - 1 << "\n";
continue;
}
if (wins == 0) {
if (k == 0)
cout << 0 << "\n";
else
cout << 2 * k - 1 << "\n";
continue;
}
if (s[0] == 'L') losing_streaks[0] = 1e8;
if (s[n - 1] == 'L') losing_streaks.back() = 1e8;
sort(losing_streaks.begin(), losing_streaks.end());
int temp = k;
for (int ls : losing_streaks) {
if (ls > k) break;
k -= ls;
count++;
}
cout << count + (2 * temp) << "\n";
}
}
| 8 | CPP |
import sys
#def solve(a,b,c,d):
def solve(outcomes,k,raw):
#print(outcomes,k)
n = len(outcomes)
nw = sum(outcomes)
nl = n-nw
last = 0
score = 0
for s in outcomes:
score += 0 if s==0 else (1 if last==0 else 2)
last = s
#print(raw,' base score',score,'NL=',nl,'NW=',nw)
if k == 0:
# return current score
return score
elif k >= nl:
return 2*n-1
elif nw == 0:
return 2*k-1
else:
#DP = [[0]*(k+1) for i in range(n)]
#for i in range(1,n+1):
#for k in range(1,k+1):
#pass
'''
leading_ls = 0
for s in outcomes:
if s == 0:
leading_ls += 1
else:
break
'''
# for every W group, there's a 1-point
# if change the L right before it, you get a bonus 1
# let's count the length of each L group and the max points it would increase the total by to change all of them
# all of the single L's in between W's are worth 3
# any L after a W is worth 2
# then pick based on the average gain per char changed
lgroups = [len(g) for g in raw.split('W') if len(g)>0]
#print(raw,lgroups)
if outcomes[0] == 0:
lgroups.pop(0) # those are leading L's
if nw > 0:
if outcomes[-1] == 0:
lgroups.pop() # those are trailing L's
# close as many as possible, if can close all do as many of
# leading as possible
lgroups.sort()
#print(lgroups)
#print(leading_ls,lgroups,k,'base score:',score)
for grp in lgroups:
if k >= grp:
score += 2*grp+1
k -= grp
else:
score += 2*k
k = 0
break
if k > 0:
score += 2*k
k = 0
return score
if __name__ == '__main__':
IN = [x.strip() for x in sys.stdin.readlines()]
T = int(IN[0])
cur = 1
for ti in range(T):
n,k = [int(x) for x in IN[cur].split(' ')]
outcomes = [1 if c=='W' else 0 for c in IN[cur+1]]
res = solve(outcomes,k,IN[cur+1])
print(res)
cur += 2
| 8 | PYTHON3 |
import sys
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
t=int(input())
for _ in range(t):
n,k=[int(x) for x in input().split()]
s=list(input())
#score=2*(Wcnts) - n(Wstreaks)
#n(Wstreaks)=n(Lstreaks excluding start and end) + 1
Wcnts=min(s.count('W')+k,n)
lStreaks=[]
isStart=True
lStreakLen=0
for c in s:
if c=='W':
isStart=False
if lStreakLen>0:
lStreaks.append(lStreakLen)
lStreakLen=0
else:
if isStart==False:
lStreakLen+=1
#don't add the last lStreakLen to lStreaks because it's the one at the end
lStreaks.sort(reverse=True)
while lStreaks and lStreaks[-1]<=k:
k-=lStreaks[-1]
lStreaks.pop()
if Wcnts>0:
ans=2*Wcnts-(len(lStreaks)+1)
else:
ans=0
print(ans) | 8 | PYTHON3 |
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, trunc
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
for _ in range(int(inp())):
n, kx = lmp()
s = inp()
if s.count('W')==0:
print(max(0, 2*kx-1))
continue
c = 0
l = 0
t = False
for i in s:
if i=='L':
l += 1
t = False
else:
if t: c+=2
else:
t = True
c += 1
i = 0
x = 0
ml = []
while i<n and s[i]=='L': i+=1
j = n-1
while j>-1 and s[j]=='L': j-=1
for k in range(i, j+1):
if s[k] == 'L':
x += 1
else:
if x!=0:
ml.append(x)
x = 0
ml.sort()
for i in ml:
if kx==0:
break
if kx>=i:
c += 2*i+1
l-=i
kx-=i
else:
c += 2*kx
l-=kx
kx = 0
if kx>0 and l>0:
c += 2*min(kx, l)
print(c)
| 8 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=list(map(int,input().split()))
s=str(input())
ind=[]
arr=[]
p=0
for i in range(n):
arr.append(s[i])
if s[i]=="W":
ind.append(i+1)
p+=1
if p==0:
if k==0:
print(0)
else:
print(1+(2*(k-1)))
else:
ans=0
i=0
q=-1
while i<n:
if arr[i]=="W":
ans+=1
q=i
break
i+=1
for i in range(q+1,n):
if arr[i]=="W":
if arr[i-1]=="W":
ans+=2
else:
ans+=1
if k==0:
print(ans)
else:
diff=[]
f=0
for i in range(p-1):
if ind[i+1]-ind[i]-1>0:
diff.append(ind[i+1]-ind[i]-1)
f+=1
diff.sort()
i=0
while k>0 and i<f:
if diff[i]==1:
diff[i]-=1
i+=1
k-=1
ans+=3
else:
diff[i]-=1
k-=1
ans+=2
if k>0:
c=(ind[0]-1)+(n-ind[-1])
ans+=(2*min(c,k))
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c;
int num, f = 1;
while (c = getchar(), !isdigit(c))
if (c == '-') f = -1;
num = c - '0';
while (c = getchar(), isdigit(c)) num = num * 10 + c - '0';
return num * f;
}
int n, k, cnt, a[100009], tot, ans;
char c[100009];
void work() {
n = read();
k = read();
cnt = 0;
tot = 0;
ans = 0;
scanf("%s", c + 1);
for (int i = 1; i <= n; i++) cnt += c[i] == 'L';
for (int i = 1; i <= n; i++) {
if (c[i] == 'W') {
if (i == 1 || c[i - 1] == 'L')
ans++;
else
ans += 2;
}
}
if (k == 0) {
printf("%d\n", ans);
return;
}
if (k > cnt) {
printf("%d\n", 2 * n - 1);
return;
}
if (cnt == n) {
printf("%d\n", 2 * k - 1);
return;
}
int now = 1;
cnt = 0;
while (c[now] != 'W') now++;
for (; now <= n; now++) {
if (c[now] == 'W') {
if (cnt > 0) a[++tot] = cnt;
cnt = 0;
} else {
cnt++;
}
}
sort(a + 1, a + 1 + tot);
for (int i = 1; i <= tot; i++) {
if (k < a[i]) break;
k -= a[i];
ans += a[i] * 2 + 1;
}
if (k) ans += 2 * k;
printf("%d\n", ans);
}
int main() {
int Case = read();
while (Case--) work();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 5;
long long lst[Max], sum[Max];
const int max_n = 1e5 + 100;
char a[max_n];
bool cmp(pair<int, int> p1, pair<int, int> p2) {
if (p1.second == p1.first * 2 && p2.second == p2.first * 2)
return p1.first < p2.first;
else if (p1.second == p1.first * 2 + 1 && p2.second == p2.first * 2 + 1)
return p1.first < p2.first;
else if (p1.second == p1.first * 2 + 1)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
int t;
scanf("%d", &t);
while (t--) {
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
for (int i = 1; i <= 2; i++) {
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{
{ break; }
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
int n, k;
scanf("%d %d", &n, &k);
scanf("%s", &a[1]);
bool flag = false;
int kk = 0;
for (int i = 1; i <= n; ++i)
if (a[i] == 'W')
flag = true;
else
++kk;
k = min(kk, k);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == 'W') {
if (a[i - 1] == 'W')
ans += 2;
else
ans++;
}
}
if (!flag) {
printf("%d\n", max(0, k * 2 - 1));
continue;
}
vector<pair<int, int> > res;
int cnt = 0;
int id1, id2;
for (id1 = 1; id1 <= n; ++id1) {
if (a[id1] == 'L')
++cnt;
else {
if (cnt != 0) res.push_back(make_pair(cnt, 2 * cnt));
break;
}
}
cnt = 0;
for (id2 = n; id2 >= 1; --id2) {
if (a[id2] == 'L')
++cnt;
else {
if (cnt != 0) res.push_back(make_pair(cnt, 2 * cnt));
break;
}
}
cnt = 0;
for (int i = id1; i <= id2; ++i) {
if (a[i] == 'L')
cnt++;
else {
if (cnt != 0) res.push_back(make_pair(cnt, cnt * 2 + 1));
cnt = 0;
}
}
sort(res.begin(), res.end(), cmp);
for (int i = 0; i < res.size(); ++i) {
if (k >= res[i].first) {
k -= res[i].first;
ans += res[i].second;
}
}
printf("%d\n", ans + k * 2);
}
}
| 8 | CPP |
t = int(input())
for _ in range(t):
n, k = [int(m) for m in input().split()]
s = list(input())
firstwin = s.index('W') if 'W' in s else -1
if firstwin == -1:
print(max(min(k, len(s)) * 2 - 1, 0))
continue
left = firstwin
noleft = True
A = []
front, back = None, None
if left != 0:
front = (0, left)
for i in range(firstwin, len(s)):
if s[i] == 'L' and noleft:
left = i
noleft = False
elif s[i] == 'W' and not noleft:
A.append((left, i))
noleft = True
if not noleft:
back = (left, len(s))
A.sort(key=lambda a : a[1] - a[0])
if k > 0:
for a in A:
for i in range(*a):
k -=1
s[i] = 'W'
if k <= 0:
break
if k <= 0:
break
if k > 0:
if back:
for i in range(*back):
s[i] = 'W'
k -= 1
if k <= 0:
break
if front and k > 0:
for i in reversed(range(*front)):
s[i] = 'W'
k -= 1
if k <= 0:
break
res = 0 if s[0] == 'L' else 1
for i in range(1, len(s)):
if s[i] == 'W' == s[i - 1]:
res += 2
elif s[i] == 'W':
res += 1
print(res) | 8 | PYTHON3 |
import io
import os
import sys
import math
from operator import attrgetter
from typing import NamedTuple
from collections import deque
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
input = sys.stdin.readline
# fileno = sys.stdin.fileno()
# input = io.BytesIO(
# os.read(fileno, os.fstat(fileno).st_size)
# ).readline
class Block(NamedTuple):
size: int
profit: int
ratio: float
is_begin: bool
is_end: bool
def fill_gap(size, is_begin, is_end, k):
take = min(size, k)
inc = 2 * take
if is_begin and (take == size or is_end):
inc -= 1
if not is_end and take == size:
inc += 1
return inc
T = int(input())
for t in range(T):
N, K = map(int, input().split())
S = input().strip()
loss = win = 0
L = []
current_len = 0
ans = 0
for i, s in enumerate(S):
if s == 'W':
prev = S[i-1] if i else 'L'
ans += 2 if prev == 'W' else 1
win += 1
if current_len:
profit = fill_gap(
size=current_len,
is_begin=current_len == i,
is_end=False,
k=N+1,
)
L.append(Block(
current_len,
profit,
profit / current_len,
current_len == i,
False,
))
current_len = 0
else:
current_len += 1
loss += 1
if current_len:
profit = fill_gap(
size=current_len,
is_begin=current_len==N,
is_end=True,
k=N+1,
)
L.append(Block(
current_len,
profit,
profit / current_len,
is_begin=current_len==N,
is_end=True,
))
L.sort(key=lambda block: (block.ratio, -block.size), reverse=True)
if K >= loss:
print(N*2 - 1)
continue
for block in L:
if K == 0:
break
# print(block)
ans += fill_gap(block.size, block.is_begin, block.is_end, K)
K -= min(K, block.size)
print(ans) | 8 | PYTHON3 |
import sys
import math
from collections import defaultdict,Counter
import operator
input=sys.stdin.readline
def print(x):
sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n,k=map(int,input().split())
s=input()
c=0
l=[]
ans=0
for j in range(n):
if s[j]=='W':
if j==0 or s[j-1]=='L':
ans+=1
else:
ans+=2
start=-1
for j in range(n):
if s[j]=='L':
c+=1
if start==-1:
start=j
else:
if c>0:
if start==0:
l.append([c,1])
else:
l.append([c,0])
c=0
start=-1
if c>0:
if start==0:
l.append([c,2])
else:
l.append([c,1])
# print(ans)
l.sort(key=operator.itemgetter(1,0))
# print(l)
for j in l:
if j[0]<=k:
if j[1]==0:
ans+=2*j[0]+1
elif j[1]==1:
ans+=2*j[0]
else:
ans+=2*j[0]-1
k-=j[0]
else:
if j[1]==2:
ans+=max(0,2*k-1)
else:
ans+=2*k
break
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod2 = 1e9 + 7;
bool prime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPerfectSquare(long long int x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
bool isPowerOfTwo(long long int n) { return n > 0 && !(n & (n - 1)); }
bool subsequence_checker(string str1, string str2, long long int m,
long long int n) {
if (m == 0) return true;
if (n == 0) return false;
if (str1[m - 1] == str2[n - 1])
return subsequence_checker(str1, str2, m - 1, n - 1);
return subsequence_checker(str1, str2, m, n - 1);
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) return a.second < b.second;
return (a.first > b.first);
}
long long int gcd(long long int p, long long int q) {
if (p % q == 0) return q;
return gcd(q, p % q);
}
long long int countDigit(long long int n) { return floor(log10(n) + 1); }
long long int power(long long int a, long long int n) {
if (n == 0) return 1;
if (n % 2) return (a * power((a * a) % 998244353, n / 2)) % 998244353;
return power((a * a) % 998244353, n / 2);
}
long long int countDivisors(long long int n) {
long long int count = 0;
for (long long int i = 1; i * i < n; i++) {
if (n % i == 0) count++;
}
for (long long int i = sqrt(n); i >= 1; i--) {
if (n % i == 0) count++;
}
return count;
}
void printDivisors(int n) {
for (int i = 1; i * i < n; i++) {
if (n % i == 0) cout << i << " ";
}
for (int i = sqrt(n); i >= 1; i--) {
if (n % i == 0) cout << n / i << " ";
}
}
long long int setBitNumber(long long int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n = n + 1;
return (n >> 1);
}
void solve() {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
long long int l = 0, w = 0;
long long int cur = 0, last = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == 'W') {
cur++;
if (last) cur++;
w++;
last++;
} else {
last = 0;
l++;
}
}
if (k == 0 or l == 0) {
cout << cur;
return;
}
if (k >= l) {
cout << 2 * (n - 1) + 1;
return;
}
last = -1;
map<long long int, long long int> m;
long long int fir = -1;
for (long long int i = 0; i < n; i++) {
if (s[i] == 'W') {
if (last == -1) {
last = i;
fir = i;
} else {
if (i - last - 1 == 0) {
last = i;
continue;
}
m[i - last - 1]++;
last = i;
}
}
}
if (last != -1)
fir += (n - last - 1);
else {
if (k == 1) {
cout << 1;
} else {
cout << 2 * (k - 1) + 1;
}
return;
}
for (auto i : m) {
long long int d = i.second;
long long int gap = i.first;
long long int fil = gap * d;
long long int bhadega = 2 * gap + 1;
if (k >= fil) {
k -= fil;
cur += bhadega * d;
if (k == 0) {
cout << cur;
return;
}
} else {
long long int can = k / gap;
cur += bhadega * can;
k -= can * gap;
cur += k * 2;
cout << cur;
return;
}
}
if (k < fir) {
cur += (k * 2);
} else {
cur += (fir * 2);
}
cout << cur;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 8 | CPP |
for _ in " "*int(input()):
n,k=map(int,input().split())
s=list(input())
if "W" not in s:
print(max((min(k,n)*2)-1,0))
elif k >= s.count("L"):
print((n*2)-1)
else:
cnt,sm,ind=list(),s.count("W"),s.index("W")
for i in range(ind+1,n):
if s[i] == "W":
cnt.append(i-ind-1)
ind=i
cnt.sort()
for i in cnt:
if k >= i:
sm+=(2*i)+1
k-=i
else:
break;
if k>0:
sm+=(2*k)
print(sm) | 8 | PYTHON3 |
# ========== //\\ //|| ||====//||
# || // \\ || || // ||
# || //====\\ || || // ||
# || // \\ || || // ||
# ========== // \\ ======== ||//====||
# code
def solve():
n, m = map(int, input().split())
s = input()
s = s[:n]
p = 0
gaps = []
points = 0
lastsect = 0
firstsect = 0
wins = len(list(filter(lambda x : x == 'W', s)))
if wins == 0:
m = min(m, n)
if m == 0:
print(0)
else:
print(2 * m - 1)
return
if m + wins >= n:
print(2 * n - 1)
return
i = 0
while i < n and s[i] == 'L':
i += 1
firstsect = i
for j, v in enumerate(s[i:]):
if v == 'L':
p += 1
else:
if p > 0:
gaps.append(p)
p = 0
points += 1 + (1 if (j + i > 0 and s[j + i - 1] == 'W') else 0)
if p > 0:
lastsect = p
gaps.sort()
# print(gaps, points)
i = 0
k = m
while i < len(gaps) and k > 0:
if gaps[i] > k:
points += 2 * k
k = 0
else:
points += 2 * gaps[i] + 1
k -= gaps[i]
i += 1
points += 2 * min(k, firstsect)
k -= min(k, firstsect)
points += 2 * min(k, lastsect)
print(points)
def main():
t = 1
t = int(input())
for _ in range(t):
solve()
if __name__ == "__main__":
main() | 8 | PYTHON3 |
import io
import os
from collections import Counter, defaultdict, deque
def makeRepeat(arr):
repeat = [[arr[0], 0]]
for x in arr:
if x == repeat[-1][0]:
repeat[-1][1] += 1
else:
repeat.append([x, 1])
return repeat
def solve(N, K, S):
if all(x == "L" for x in S):
if K:
return (min(N, K) - 1) * 2 + 1
else:
return 0
repeats = makeRepeat(S)
firstStreak = 0
lastStreak = 0
if repeats[-1][0] == "L":
lastStreak = repeats.pop()[1]
if repeats and repeats[0][0] == "L":
firstStreak = repeats[0][1]
repeats = repeats[1:]
base = 0
streaks = []
for ch, repeat in repeats:
if ch == "L":
streaks.append(repeat)
else:
base += (repeat - 1) * 2 + 1
streaks.sort()
# print(S, K, base)
# print(streaks, lastStreak)
total = 0
for x in streaks:
if x <= K:
total += x * 2 + 1
K -= x
else:
x = min(K, x)
total += x * 2
K -= x
# print("after", total, K, firstStreak, lastStreak)
if K and lastStreak:
x = min(K, lastStreak)
total += x * 2
K -= x
if K and firstStreak:
x = min(K, firstStreak)
total += x * 2
K -= x
return base + total
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
N, K = [int(x) for x in input().split()]
S = input().decode().rstrip()
ans = solve(N, K, S)
print(ans)
| 8 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.