solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
import sys
input=sys.stdin.readline
t=int(input())
for you in range(t):
l=input().split()
n=int(l[0])
k=int(l[1])
s=input()
lfi=[i for i in s]
ans=0
poss=1
for i in s:
if(i=='W'):
poss=0
break
if(poss):
print(max(2*k-1,0))
continue
if(s[0]=='W'):
ans+=1
for i in range(1,n):
if(s[i]=='W' and s[i-1]=='W'):
ans+=2
elif(s[i]=='W'):
ans+=1
l=[]
start=0
end=-1
done=0
ext1=0
#print(ans)
for i in range(n):
if(s[i]=='L'):
ext1+=1
else:
break
for i in range(ext1,n):
if(done):
if(s[i]=='W'):
l.append(end-start+1)
done=0
else:
end+=1
else:
if(s[i]=='L'):
start=i
end=i
done=1
ext=0
if(done):
ext=end-start+1
lfi=[]
for i in range(len(l)):
lfi.append(l[i])
lfi.sort()
z=len(lfi)
i=0
done1=0
done2=0
#print(ans)
while(i<z):
if(k==0):
break
if(k>=lfi[i]):
k-=lfi[i]
ans+=(2*lfi[i]+1)
i+=1
else:
ans+=(2*k)
k=0
break
#print(ans,k)
#print(lfi,ans)
#print(ext1,k)
ans+=2*min(ext,k)
k-=min(ext,k)
if(done1==0):
if(ext1 and k):
ans+=(2*min(ext1,k))
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<int, pair<int, int>>> v;
int b = -1, mn = 0, mx = n - 1;
bool ok = (s[0] == 'W');
for (int i = 0; i < n; i++) {
if (s[i] == 'W' && b == -1) {
ok = 1;
b = i;
mn = i;
} else if (s[i] == 'W') {
if (ok) {
b = i;
continue;
}
v.push_back(make_pair(i - b, make_pair(b, i)));
b = i;
ok = 1;
} else
ok = 0;
}
mx = b;
sort(v.begin(), v.end());
if (v.size() == 0) {
for (int i = mn; i >= 0; i--) {
if (!k) break;
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
for (int i = 0; i < n; i++) {
if (!k) break;
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
} else {
for (int i = 0; i < (int)v.size(); i++) {
for (int j = v[i].second.first + 1; j < v[i].second.second; j++) {
if (!k) break;
if (s[j] == 'L') {
k--;
s[j] = 'W';
}
}
}
if (k) {
for (int i = mn; i >= 0; i--) {
if (!k) break;
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
for (int i = 0; i < n; i++) {
if (!k) break;
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
if (!i || s[i - 1] != s[i])
ans++;
else
ans += 2;
}
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
import math
T = int(input())
#lets = 'abcdefghijklmnopqrstuvwxyz'
#key = {lets[i]:i for i in range(26)}
for t in range(T):
#n = int(input())
n,k = map(int,input().split())
#a = list(map(int,input().split()))
a = list(input())
d = False
gaps = []
l = 0
st = (a[0]!='W')
for i in range(n):
if a[i] == 'L':
l+=1
elif l!=0 and not st:
gaps.append(l)
l = 0
elif l!=0:
st = 0
l = 0
#print(gaps)
k1= k
gaps.sort()
lg = len(gaps)
for i in range(lg):
k-=gaps[i]
if k>=0:
lg-=1
else:
break
#print(gaps)
ans = 2*(min(a.count('W')+k1,n))
ans -= lg+1
#print(ans)
"""if k>0:
ans += 2*k"""
#print(gaps,lg)
print(max(ans,0)) | 8 | PYTHON3 |
# cook your dish here
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 |
for x in range(int(input())):
n, k = map(int, input().split())
string = list(input())
lose = []
count = 0
score, first, last = 0, 0, 0
for i in range(n-1):
if string[i] == string[i+1]:
count += 1
if i == n-2:
if string[i] == 'L':
lose.append(count+1)
if string[i] == 'W':
score = score+(count)*2+1
break
else:
if string[i] == 'W':
score = score+(count)*2+1
count = 0
if i == n-2:
lose.append(1)
else:
lose.append(count+1)
count = 0
if i == n-2:
score += 1
if n == 1:
if string[0] == 'W':
score = 1
else:
last = 1
else:
if string[-1] == 'L' and lose:
last = lose.pop()
if string[0] == 'L' and lose:
first = lose.pop(0)
lose = sorted(lose)
for i in lose:
if k-i < 0:
score = score+(k*2)
k = 0
break
else:
k -= i
score = score+(i*2)+1
if k >= last and score > 0:
score = score+(last*2)
k -= last
elif last > k and score > 0:
score = score+(k*2)
k = 0
elif last > 0 and k >= last:
score = score+last*2-1
k -= last
elif k > 0 and last > k:
score = score+k*2-1
k = 0
if k >= first and score > 0:
score = score+(first*2)
k -= first
elif first > k and score > 0:
score = score+(k*2)
k = 0
print(score)
| 8 | PYTHON3 |
t = int(input())
for i in range(t):
n, k= map(int, input().split())
s = input()
w =0
l = 0
otv = 0
d=[]
for j in range(n):
if w == 1 and s[j] == 'L':
l +=1
if s[j] =='W':
otv +=1
if j!=0:
if s[j-1]=='W':
otv+=1
w = 1
if l !=0:
d.append(l)
l=0
d.sort()
j = 0
while j<len(d) and k >=d[j]:
otv+=2*d[j]+1
k -=d[j]
j+=1
otv += 2*k
if w ==0:
otv = 2*k - 1
if otv > 2*n -1:
otv = 2*n -1
if otv < 0:
otv = 0
print(otv) | 8 | PYTHON3 |
import sys as _sys
WIN = 'W'
LOSE = 'L'
def main():
t = int(input())
for i_t in range(t):
n, k = _read_ints()
s = _read_line()
result = find_max_score_after_changing(s, k)
print(result)
def _read_line():
result = _sys.stdin.readline()
assert result[-1] == "\n"
return result[:-1]
def _read_ints():
return map(int, _read_line().split())
def find_max_score_after_changing(games_results, changes_n):
if len(games_results) == 0:
return 0
if len(games_results) == 1:
if games_results[0] == WIN:
result = 1
elif changes_n > 0:
result = 1
else:
result = 0
return result
lose_n = games_results.count(LOSE)
changes_n = min(changes_n, lose_n)
if lose_n == len(games_results):
if changes_n == 0:
result = 0
else:
result = 2 * changes_n - 1
return result
curr_score = 1 if games_results[0] == WIN else 0
for i in range(1, len(games_results)):
if games_results[i] == WIN:
if games_results[i-1] == WIN:
curr_score += 2
else:
curr_score += 1
empty_spaces = games_results.replace(WIN, ' ').split()
if games_results[0] == LOSE:
empty_spaces = empty_spaces[1:]
if games_results[-1] == LOSE:
empty_spaces = empty_spaces[:-1]
distances_between_islands = sorted(map(len, empty_spaces))
changes_lost = 0
islands_united = 0
for distance in distances_between_islands:
if distance <= changes_n:
changes_lost += distance
changes_n -= distance
islands_united += 1
else:
changes_lost += changes_n
changes_n = 0
break
curr_score += (changes_lost + changes_n) * 2
curr_score += islands_united
return curr_score
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
from math import inf
for _ in range(int(input())):
n, k = map(int,input().split())
l = [1 if i == 'W' else 0 for i in list(input())]
s = sum(l)
if s + k >= n:
print((2 * n) - 1)
continue
elif s == 1:
print((2 * min(n - 1, k)) + 1)
continue
elif s == 0:
print(max(2 * k - 1, 0))
continue
ind = []
prev = -inf
for i in range(n):
if l[i] == 1:
ind.append(i - prev - 1)
prev = i
if ind:
ind.sort()
for d in ind:
if d <= k:
s += 2 * d + 1
k -= d
if k > 0:
s += 2 * k
print(s)
| 8 | PYTHON3 |
t = int(input())
for t_ in range(t):
n,k = map(int,input().split())
s = input()
gaps = [len(x) for x in s.split('W') if len(x)>0]
runs = [len(x) for x in s.split('L') if len(x)>0]
# trim ends
ends = 0
if s[0]=='L':
ends+=gaps[0]
del gaps[0]
if s[-1]=='L' and len(gaps)>0:
ends+=gaps[-1]
del gaps[-1]
gaps.sort()
i=0
while k>0 and i<len(gaps):
if gaps[i]<=k:
k-=gaps[i]
gaps[i] = 0
i+=1
else:
gaps[i]-=k
k=0
new_gaps = [g for g in gaps if g>0]
if k>0 and ends>0:
if ends>=k:
ends-=k
else:
ends=0
score = (n-sum(new_gaps)-ends)*2 - (len(new_gaps)+1)
score = max(score,0)
print(score)
| 8 | PYTHON3 |
# from collections import defaultdict, Counter, deque
# from heapq import heappop, heappush, heapify
# from functools import lru_cache, reduce
# import bisect
# from itertools import permutations, combinations, combinations_with_replacement
t = int(input())
arr = []
for _ in range(t):
n, k = tuple(map(int, input().split()))
arr.append( (n,k,input() ) )
# Cases: All L's, All W's, mix of L's and W's
for n,k,string in arr:
# O(n)
# each L -> W adds at most 3, 2 in general tho [exceptions are left end and right end]
numL = 0
Lchain = string.split('W')
Lchain = list(map(lambda x: len(x),Lchain))
Wchain = string.split('L')
Wchain = list(map(lambda x: len(x),Wchain))
# Handles k >= number of L's or all W's
if k >= sum(Lchain):
print( 2*len(string)-1 )
continue
# Handles all L's
if len(Lchain) == 1:
print( max(0,2*k-1) )
continue
res = 0
# sum of all W's
for i in Wchain:
if i != 0:
res += 2*i - 1
# further increase res
# front, back = Lchain[0],Lchain[-1]
Lchain = [Lchain[i] for i in range(len(Lchain)) if i != 0 and i != len(Lchain)-1]
Lchain.sort()
# print(n,k,"initial",res)
for i in Lchain:
if i == 0:
pass
elif k >= i:
res += 2*i + 1
k -= i
else:
res += 2*k
k = 0
break
res += 2*k
print(res)
# Test cases
'''
10
5 2
WLWLL
6 5
LLLWWL
7 1
LWLWLWL
15 5
WWWLLLWWWLLLWWW
40 7
LLWLWLWWWLWLLWLWWWLWLLWLLWLLLLWLLWWWLWWL
1 0
L
1 1
L
6 1
WLLWLW
5 2
WWWWW
5 2
LLLLL
'''
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
const double pi = acos(-1.0);
long long int calcScore(int n) {
if (n == 0) return 0;
return 2 * (n)-1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
string s;
cin >> n >> k >> s;
int winning_streak = 0;
int win = 0, losses = 0;
vector<int> losing_streak;
for (int i = 0; i < n; i += 1) {
if (s[i] == 'W') {
win++;
if (i == 0 || s[i - 1] == 'L') winning_streak++;
}
if (s[i] == 'L') {
losses++;
if (i == 0 || s[i - 1] == 'W') losing_streak.push_back(0);
losing_streak.back()++;
}
}
if (k >= losses) {
cout << 2 * n - 1 << endl;
continue;
}
if (win == 0) {
cout << max(0, 2 * k - 1) << endl;
continue;
}
win += k;
if (s[0] == 'L') losing_streak[0] = 1e8;
if (s[n - 1] == 'L') losing_streak.back() = 1e8;
sort(losing_streak.begin(), losing_streak.end());
for (auto ls : losing_streak) {
if (ls > k) break;
k -= ls;
winning_streak--;
}
cout << 2 * win - winning_streak;
cout << endl;
}
return 0;
}
| 8 | CPP |
def reverse(li,i,k):
i-=1
t=0
while(k>0 and i>=0):
if(li[i]=='L'):
li[i]='W'
t+=1
else:
return t
i-=1
k-=1
return t
def process():
n,k=list(map(int,input().split()))
li=list(input())
# print(li)
if(n==1 and k==1):
print(1)
return
if(n==1 and k==0):
if(li[0]=='W'):
print(1)
else:
print(0)
return
last_win=0 if li[0]=='W'else -1
flag = 1 if li[0] == 'W' else 0
between_wins=[]
for i in range(1,n):
if(flag==1 and li[i]=='W'):
last_win+=1
elif(li[i]=='L'):
flag=0
elif(li[i]=='W'):
flag=1
if(last_win!=-1):
between_wins.append((last_win+1,i-1))
last_win = i
between_wins.sort(key=lambda x:x[1]-x[0]+1)
temp=[]
if(li[0]=='L'):
ans=0
flag=0
for i in range(n):
if(li[i]=='W'):
ans=i
flag=1
break
if(flag):
temp.append((ans-1,0))
if(li[-1]=='L'):
ans=n-1
flag=0
for i in reversed(range(n)):
if(li[i]=='W'):
flag=1
ans=i+1
break
if(flag):
temp.append((ans,n-1))
temp.sort(key=lambda x:abs(x[1]-x[0])+1)
between_wins.extend(temp)
# print(between_wins)
for i in between_wins:
if(i[1]>=i[0]):
for j in range(i[0],i[1]+1):
if(k>0):
k-=1
li[j]='W'
else:
break
else:
for j in reversed(range(i[1],i[0]+1)):
if (k > 0):
k -= 1
li[j] = 'W'
else:
break
# print(between_wins)
if(between_wins==[]):
for i in range(min(n,k)):
li[i]='W'
points=1 if li[0]=='W' else 0
for i in range(1,n):
if(li[i]=='W' and li[i-1]=='W'):
points+=2
elif(li[i]=='W'):
points+=1
# print(li)
print(points)
tests=int(input())
for i in range(tests):
process() | 8 | PYTHON3 |
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
# mod=1000000007
mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
def solve():
for _ in range(ii()):
n,k = mi()
s = si()
a = []
c = 0
ans = 0
if s[0] == 'W':
a.append(0)
ans += 1
else:
c += 1
for i in range(1,n):
if s[i] == 'W':
if c > 0:
a.append(c)
c = 0
if s[i-1] == 'W':
ans += 2
else:
ans += 1
else:
c += 1
a.append(c)
if len(a) >= 2:
b = a[1:]
b.pop()
b.sort()
for i in b:
if i > k:
ans += 2*k
k = 0
break
else:
ans += 2*i
ans += 1
k -= i
if(ans == 0):
ans -= 1
x = min(k,a[0])
ans += 2*x
k -= x
x = min(k,a[-1])
ans += 2*x
if n == 1:
ans = min(ans,1)
print(max(ans,0))
if __name__ =="__main__":
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = numeric_limits<int>::max();
const int MIN = numeric_limits<int>::min();
const long long mod = 1e9 + 7;
const int N = 100010;
void FastRead() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
inline char Nowchar() {
static char buf[1 << 20], *p1 = buf, *p2 = buf;
bool flag =
(p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2);
return flag ? EOF : *p1++;
}
inline int Read() {
int x = 0, f = 1;
static char c = Nowchar();
for (; c > '9' || c < '0'; c = Nowchar()) {
if (c == '-') f = -1;
}
for (; c <= '9' && c >= '0'; c = Nowchar()) {
x = (x << 3) + (x << 1) + c - 48;
}
return x * f;
}
void Test() { return; }
void Solve() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> a;
string s;
cin >> s;
int lwp = -2;
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
if (lwp != i - 1 && lwp >= 0) {
a.push_back(i - lwp - 1);
}
ans += (lwp == i - 1) + 1;
lwp = i;
cnt++;
}
}
k = min(n - cnt, k);
ans += 2 * k;
if (lwp < 0) {
if (k > 0) {
ans--;
}
} else {
sort(a.begin(), a.end());
for (auto x : a) {
if (k >= x) {
ans++;
k -= x;
}
}
}
cout << ans << endl;
}
}
int main(int argc, char** argv) {
Solve();
return 0;
}
| 8 | CPP |
t = int(input())
for _ in range(t):
n,k=list(map(int,input().split()))
s=list(input())
mode=0
ls=[]
count=0
for i in range(n):
if(s[i]=='W'):
if(mode==1):
if(count!=0):
ls.append(count)
mode=1
count=0
else:
count+=1
ls.sort()
sum=0
prev='L'
for i in range(n):
if(s[i]=='W'):
if(prev=='W'):
sum+=2
else:
sum+=1
prev=s[i]
for x in ls:
if(x<=k):
k-=x
sum+=2*x+1
else:
sum+=2*k
k=0
count=0
for i in range(n):
if(s[i]=='L'):
count+=1
else:
break
for i in reversed(range(n)):
if(s[i]=='L'):
count+=1
else:
break
if(count==2*n):
sum+=max(2*min(k,n)-1,0)
else:
sum+=2*min(k,count)
# print(ls)
print(sum) | 8 | PYTHON3 |
# B. Шахматный мошенник https://codeforces.com/contest/1427/problem/B
import sys
# sys.stdin = open('20201010-b.txt', encoding='utf-8')
input = sys.stdin.readline
for _ in range(int(input())):
n, k = map(int, input().split())
a = input().rstrip()
c = a.count('L')
k = min(k, c)
# количество очков на данный момент
out = sum(
2 if (i > 0 and a[i-1] == 'W') else 1
for i, v in enumerate(a)
if v == 'W'
)
if k == 0:
print(out)
continue
# если нет побед
if out == 0:
out -= 1
out += k * 2
# если где-то заполнятся промежутки между W то плюс 1 очко
# без начала и конца строки
temp = sorted(len(v) for v in a.split('W')[1:-1] if v)
for v in temp:
if v <= k:
out += 1
k -= v
else:
break
print(out)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 1000005;
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') ans++;
}
ans = min(ans + k, n);
ans = ans * 2;
long long streak = 0;
vector<long long> v;
long long x = -1;
long long y = -1;
for (long long i = 0; i < n; i++)
if (s[i] == 'W') {
x = i;
break;
}
for (long long i = n - 1; i >= 0; i--)
if (s[i] == 'W') {
y = i;
break;
}
if (x == -1 || y == -1) {
k = min(k, n);
cout << max(2 * k - 1, 0LL) << "\n";
return;
}
for (long long i = x; i < y + 1; i++) {
if (s[i] == 'W') continue;
long long cnt = 0;
while (i < n && s[i] == 'L') {
cnt++;
i++;
}
v.push_back(cnt);
}
for (long long i = 0; i < n; i++) {
if (s[i] == 'L') continue;
streak++;
long long cnt = 0;
while (i < n && s[i] == 'W') {
i++;
}
}
sort((v).begin(), (v).end());
long long sum = 0;
long long cc = 0;
for (auto i : v) {
if (k >= i) {
k -= i;
cc++;
} else
break;
}
cout << max(ans - max(1LL, streak - cc), 0LL) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 8 | CPP |
import sys,math
N=int(input())
for i in range(N):
n,c=list(map(int,sys.stdin.readline().strip().split()))
g_arr=list(sys.stdin.readline().strip())
l_arr=[]
l,r=-1,-1
g_arr.append('W')
for i in range(n+1):
if g_arr[i]=='L' and l==-1:
l=i
if g_arr[i]=='W'and l>-1:
r=i-1
l_arr.append((l,r))
l,r=-1,-1
g_arr.pop()
l_arr.sort(key=lambda a:a[1]-a[0] if (a[0]>0 and a[1]<n-1) else math.inf)
# print(l_arr)
for i in l_arr:
if i[0]==0:
j=i[1]
while j>=i[0] and c>0:
g_arr[j]='W'
c-=1
j-=1
else:
j=i[0]
while j<=i[1] and c>0:
g_arr[j]='W'
c-=1
j+=1
if c==0:
break
# print(g_arr)
pts,w_pt=0,1
for i in range(n):
if g_arr[i]=='W':
pts+=w_pt
if w_pt==1:
w_pt=2
else:
if w_pt==2:
w_pt=1
print(pts) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool static cmp(long long int a, long long int b) { return a > b; }
int main() {
int test;
cin >> test;
while (test--) {
long long int n, l;
cin >> n >> l;
string ip;
cin >> ip;
long long int sum = 0;
long long int lose = 0;
vector<long long int> w;
for (int i = 0; i < n; i++)
if (ip[i] == 'L')
++lose;
else
w.push_back(i);
if (l >= lose) {
sum = 1 + 2 * (n - 1);
cout << sum << endl;
continue;
} else if (lose == n && l) {
sum = 1 + 2 * (l - 1);
cout << sum << endl;
continue;
}
sum = ip[0] == 'W' ? 1 : 0;
for (int i = 1; i < n; i++) {
if (ip[i] == 'W') {
if (ip[i - 1] == 'W')
sum += 2;
else
sum += 1;
}
}
if (l == 0) {
cout << sum << endl;
continue;
}
long long int start = 0;
vector<long long int> gp;
if (w[0] != 0) start = w[0];
if (w[w.size() - 1] != n - 1) start += n - w[w.size() - 1];
for (int i = 1; i < w.size(); i++) {
long long int gap = w[i] - w[i - 1] - 1;
if (gap == 0) continue;
gp.push_back(gap);
}
sort(gp.begin(), gp.end());
int i = 0;
while (l > 0 && i < gp.size()) {
if (l >= gp[i]) {
l -= gp[i];
sum += 2 * gp[i] + 1;
} else {
sum += 2 * l;
l = 0;
}
++i;
}
if (l > 0 && start > 0) {
int g = min(l, start);
sum += 2 * g;
}
cout << sum;
cout << endl;
}
}
| 8 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
if s.count('W') == n:
print(2 * n - 1)
elif s.count('L') == n:
print(max(2 * k - 1, 0))
else:
score = 0
if s[0] == 'W':
score += 1
for i in range(1, n):
if s[i] == s[i - 1] == 'W':
score += 2
elif s[i] == 'W':
score += 1
# print("score", score)
left = 0
right = n - 1
while left < n and s[left] == 'L':
left += 1
while right >= 0 and s[right] == 'L':
right -= 1
left_dist = left
right_dist = n - right - 1
s = s[left + 1: right]
s = s.split('W')
# print(s)
s = [len(line) for line in s if line]
s.sort(reverse=True)
while s and s[-1] <= k:
score += s[-1] * 2 + 1
k -= s[-1]
s.pop()
score += k * 2
print(min(score, 2 * n - 1))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) {
int diff1 = a.second - a.first + 1, diff2 = b.second - b.first + 1;
if (diff1 < diff2) {
return 1;
} else if (diff1 == diff2) {
return a.second > b.second;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int first = 0, last = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
break;
}
first++;
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == 'W') {
break;
}
last++;
}
int start = first + 1, end;
vector<pair<int, int>> v;
for (int i = first + 1; i < n - last; i++) {
if (s[i] == 'W') {
v.push_back({start, i - 1});
start = i + 1;
}
}
sort(v.begin(), v.end(), comp);
for (auto it : v) {
if (k == 0) {
break;
}
for (int i = it.first; i <= it.second and k > 0; i++) {
s[i] = 'W';
k--;
}
}
for (int i = n - last; i < n and k > 0; i++) {
s[i] = 'W';
k--;
}
for (int i = first - 1; i >= 0 and k > 0; i--) {
s[i] = 'W';
k--;
}
int ans = (s[0] == 'W');
for (int i = 1; i < n; i++) {
if (s[i] == 'L') {
continue;
}
if (s[i] == 'W') {
ans++;
}
if (s[i - 1] == 'W') {
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;
char arr[n];
int score = 0;
char last = 'O';
int gapLen = 0;
int startGap = 0;
int endGap = 0;
vector<int> gaps;
for (int i = 0; i < n; i++) {
cin >> arr[k];
if (arr[k] == 'W' && last == 'W')
score += 2;
else if (arr[k] == 'W' && last == 'L' && score > 0) {
score++;
gaps.push_back(gapLen);
gapLen = 0;
} else if (arr[k] == 'W' && last == 'L' && score == 0) {
score++;
startGap = gapLen;
gapLen = 0;
} else if (arr[k] == 'W' && last == 'O')
score++;
else if (arr[k] == 'L')
gapLen++;
last = arr[k];
}
endGap = gapLen;
sort(gaps.begin(), gaps.end());
for (int i = 0; i < gaps.size(); i++) {
if (k > gaps[i]) {
k -= gaps[i];
score += 3 + 2 * (gaps[i] - 1);
} else if (k == gaps[i]) {
score += 3 + 2 * (gaps[i] - 1);
k = 0;
break;
} else {
score += 2 * k;
k = 0;
break;
}
}
if (k > 0 && score != 0) {
int restGap = startGap + endGap;
if (k >= restGap) {
score += 2 * restGap;
} else {
score += 2 * k;
}
} else if (k > 0 && score == 0) {
score += 1 + 2 * (k - 1);
}
cout << score << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, t, k, res;
char a[N];
priority_queue<int, vector<int>, greater<int> > pq;
void inp() {
scanf("%d %d", &n, &k);
scanf("%s", a + 1);
}
void proc() {
res = 0;
int cnt = 0, dem1 = 0, dem2 = 0;
for (int i = (1), _y = (n); i <= _y; ++i) {
if (a[i] != 'L') {
if (!res)
dem1 = cnt;
else {
if (cnt) pq.push(cnt);
}
cnt = 0;
++res;
if (a[i - 1] == 'W') ++res;
} else
++cnt;
}
if (a[n] == 'L') dem2 = cnt;
while (!pq.empty() && k) {
if (pq.top() > k)
res += 2 * k, k = 0;
else
k -= pq.top(), res += 2 * pq.top() + 1;
pq.pop();
}
while (!pq.empty()) pq.pop();
if (dem1 > dem2) swap(dem1, dem2);
if (dem2 == n) {
res = (min(dem2, k) - 1) * 2 + 1;
res = max(res, 0);
printf("%d\n", res);
return;
}
if (dem2) {
if (k >= dem2) {
k -= dem2 - 1, res += 2 * (dem2 - 1);
dem2 = 1;
} else {
res += (k - 1) * 2;
dem2 -= k - 1, k = 1;
}
if (dem1) {
if (k >= dem1) {
k -= dem1 - 1, res += 2 * (dem1 - 1);
dem1 = 1;
} else {
res += (k - 1) * 2;
dem1 -= k - 1, k = 1;
}
}
}
if (dem1 && k) --k, res += 2;
if (dem2 && k) --k, res += 2;
printf("%d\n", res);
}
int main() {
scanf("%d", &t);
for (int i = (1), _y = (t); i <= _y; ++i) {
inp();
proc();
}
}
| 8 | CPP |
def find_consecutive_lose_rounds(match_log):
lose_sections_length=[]
start_winning=False
length=0
original_point=0
for i in range(len(match_log)):
char=match_log[i]
if char=="L":
length+=1
start_winning=False
else:
if start_winning:
original_point+=2
else:
original_point+=1
if length>0:
lose_sections_length.append(length)
start_winning=True
length=0
return lose_sections_length,original_point
def remove_head_tail_losing_streak(match_log):
head_length=0
tail_length=0
head_tail_length=0
is_full_loses=False
for i in range(len(match_log)):
if match_log[i]=="W":
match_log=match_log[i:]
head_length=i
break
if i == len(match_log)-1:
is_full_loses=True
return match_log,head_tail_length,is_full_loses
for j in range(len(match_log)-1,-1,-1):
if match_log[j]=="W":
tail_length=len(match_log)-j-1
match_log=match_log[:j+1]
break
head_tail_length=head_length+tail_length
return match_log,head_tail_length,is_full_loses
def find_optimal_cheat_points(head_tail_length,lose_sections_length,cheat_times):
cheat_points=0
lose_sections_length=sorted(lose_sections_length)
for lose_section_length in lose_sections_length:
if cheat_times<lose_section_length:
cheat_points+=cheat_times*2
cheat_times=0
return cheat_points
cheat_points+=((lose_section_length-1)*2+3)
cheat_times-=lose_section_length
if cheat_times>0:
cheat_points+=min(cheat_times,head_tail_length)*2
return cheat_points
def catch_all_lose_exception(match_log,cheat_times):
if cheat_times==0:
return 0
return (min(len(match_log),cheat_times)-1)*2+1
test_amount=int(input())
for i in range(test_amount):
rounds,cheat_times=tuple(map(int,input().split()))
match_log=input()
head_tail_length=0
match_log,head_tail_length,is_full_loses=remove_head_tail_losing_streak(match_log)
if is_full_loses:
print(catch_all_lose_exception(match_log,cheat_times))
else:
lose_sections_length,original_points=find_consecutive_lose_rounds(match_log)
print(find_optimal_cheat_points(head_tail_length,lose_sections_length,cheat_times)+original_points)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c[300200], d[300200], n, m, k, r, l, t, q;
long long ans, ans2, ans3, sum, sum2, mx = -1e18, mn = 1e18;
string second, s1, ss;
bool ch, ch2, ch3, ch4;
int was[200200];
set<int> st;
vector<int> vv;
pair<int, int> p[300200];
vector<pair<int, int> > v[200200];
map<string, int> ma;
double bo[200][200], g;
const int inf = 1e9, mod = 1e9 + 7, N = 1e6 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
cin >> second;
ans = 0;
q = -1;
for (int i = 0; i < second.size(); i++) {
if (second[i] == 'W') {
if (q != -1) {
v[i - q - 1].push_back(make_pair(q, i));
st.insert(i - q - 1);
if (q + 1 == i) {
ans += 2;
} else
ans++;
} else
ans++;
q = i;
}
}
if (q != -1) q = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j < v[i].size(); j++) {
if (i <= k) {
for (int l = v[i][j].first + 1; l < v[i][j].second; l++) {
second[l] = 'W';
}
k -= i;
ans += i * 2 + 1;
} else
break;
}
}
for (int i = 0; i < n; i++) {
if (second[i] == 'L') {
if (k >= 1) {
if (q != -1)
ans += 2;
else
ans++, q = 1;
k--;
} else
break;
}
}
cout << ans << '\n';
for (auto it : st) {
v[it].clear();
}
}
return 0;
}
| 8 | CPP |
def recal(l, n, k):
result = 0
cur = []
last_lose = 0
dex = 0
have_win = False
for i in l:
if i == 'W':
if last_lose == 0:
if have_win:
result += 2
else:
result += 1
have_win = True
else:
result += 1
cur += [last_lose]
last_lose = 0
else:
if have_win:
last_lose += 1
else:
dex += 1
if last_lose:
dex += last_lose
#print(result)
#print(cur)
#print(dex)
cur.sort(reverse = True)
#print(cur)
while cur and k >= cur[-1]:
result += (cur[-1] * 2 + 1)
k -= cur[-1]
cur.pop()
#print('HERE')
#print(k)
if cur:
dex += sum(cur)
if k != 0:
if have_win:
result += min(dex, k) * 2
else:
result += min(dex, k) * 2 - 1
print(result)
#print()
t = int(input())
while t > 0:
n, k = map(int, input().split())
l = input()
recal(l, n, k)
t -= 1
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
double start_moment = 0;
double get_runtime() { return 1.0 * clock() / CLOCKS_PER_SEC; }
void reset_timer() { start_moment = get_runtime(); }
double timer_time() { return get_runtime() - start_moment; }
void runtime() { cout << fixed << setprecision(5) << get_runtime() << '\n'; }
template <class T>
void read(vector<T> &a, long long n) {
T x;
a.clear();
for (long long i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
int n, k;
string second;
int main() {
ios_base::sync_with_stdio(0);
int T;
cin >> T;
while (T--) {
cin >> n >> k;
cin >> second;
int p1 = 0;
int p2 = n - 1;
while (p1 < second.size() && second[p1] == 'L') p1++;
while (p2 >= 0 && second[p2] == 'L') p2--;
if (p1 == second.size()) {
for (int i = 0; i < k; i++) {
second[i] = 'W';
}
int res = 0;
for (int i = 0; i < n; i++) {
if (second[i] == 'W') {
if (i && second[i - 1] == 'W') {
res += 2;
} else {
res += 1;
}
}
}
cout << res << '\n';
continue;
}
int cur = 0;
int pos = n;
vector<pair<int, int> > v;
for (int i = p1; i <= p2; i++) {
if (second[i] == 'L') {
cur++;
pos = min(pos, i);
} else {
v.push_back(make_pair(cur, pos));
cur = 0;
pos = n;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (k > 0) {
int can = min(k, v[i].first);
for (int j = 0; j < can; j++) {
second[v[i].second + j] = 'W';
}
k -= can;
}
}
for (int i = p2; i < n; i++) {
if (k && second[i] == 'L') {
k--;
second[i] = 'W';
}
}
for (int i = p1; i >= 0; i--) {
if (k && second[i] == 'L') {
k--;
second[i] = 'W';
}
}
int res = 0;
for (int i = 0; i < n; i++) {
if (second[i] == 'W') {
if (i && second[i - 1] == 'W') {
res += 2;
} else {
res += 1;
}
}
}
cout << res << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
const int N = 1e5 + 5;
char s[N];
int qw[N], len[N];
int main() {
int tt;
cin >> tt;
while (tt--) {
int n = read(), k = read();
scanf("%s", s + 1);
int cw = 0;
for (int i = 1; i <= n; ++i)
if (s[i] == 'W') qw[++cw] = i;
if (cw == 0 || k >= qw[cw] - qw[1] - (cw - 1)) {
cw = min(cw + k, n);
printf("%d\n", cw ? cw * 2 - 1 : 0);
} else {
for (int i = 1; i <= cw - 1; ++i) len[i] = qw[i + 1] - qw[i] - 1;
sort(len + 1, len + cw);
int s = 0, ans = 0;
for (int i = 1; i <= cw - 1; ++i)
if (s + len[i] <= k) {
s += len[i];
++ans;
}
printf("%d\n", cw + k * 2 + ans);
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool comparison(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
const long long mod = 1000000007;
const int max = 1e6 + 5, inf = 1e9 + 7;
double PI = 3.1415926536;
int c[100010], s[100010];
long long MAX(long long a, long long b) { return a > b ? a : b; }
long long int dp[100000 + 7];
void solve() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
int winning_streaks_cnt = 0;
int wins = 0;
int losses = 0;
vector<int> losing_streaks;
for (int i = 0; i < N; i++) {
if (S[i] == 'W') {
wins++;
if (i == 0 or S[i - 1] == 'L') winning_streaks_cnt++;
}
if (S[i] == 'L') {
losses++;
if (i == 0 or S[i - 1] == 'W') losing_streaks.push_back(0);
losing_streaks.back()++;
}
}
if (K >= losses) {
cout << 2 * N - 1 << "\n";
return;
}
if (wins == 0) {
if (K == 0)
cout << 0 << "\n";
else
cout << 2 * K - 1 << "\n";
return;
}
if (S[0] == 'L') losing_streaks[0] = 1e8;
if (S[N - 1] == 'L') losing_streaks.back() = 1e8;
sort(losing_streaks.begin(), losing_streaks.end());
wins += K;
for (int ls : losing_streaks) {
if (ls > K) break;
K -= ls;
winning_streaks_cnt--;
}
cout << 2 * wins - winning_streaks_cnt << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 8 | CPP |
for nt in range(int(input())):
n,k = map(int,input().split())
f = input()
if "W" not in f:
if k!=0:
print (1 + 2*(k-1))
else:
print (0)
continue
if f.count("L")<=k:
print (1 + 2*(n-1))
continue
s = f.split("W")
start, end = s[0], s[-1]
s.pop()
s.pop(0)
s.sort()
ans = 0
for i in s:
if len(i)==0:
continue
if len(i)<=k:
ans += 2*len(i)+1
k -= len(i)
else:
ans += 2*k
k = 0
ans += k*2
# print (s, ans)
for i in range(n):
if f[i]=="W":
if i==0 or f[i-1]=="L":
ans += 1
else:
ans += 2
print (ans)
| 8 | PYTHON3 |
test_cases=int(input())
for test_case in range(test_cases):
n,k = list(map(int, input().split()))
s = input()
countl=1
countw=1
score=0
l=[]
w=[]
lstart=0
if len(s)==1 and k>0:
score=1
else:
for i in range(n-1):
if s[i]=='L':
if s[i+1]=="L":
countl+=1
else:
if lstart==0 and w==[]:
lstart=countl
countl=1
else:
l.append(countl)
countl=1
else:
if s[i+1]=="W":
countw+=1
else:
w.append(countw)
countw=1
l.sort()
if s[-1]!='W':
l.append((countl,'l'))
# print(countl)
else:
w.append(countw)
for i in w:
score+=(2*i)-1
if lstart!=0:
l.append((lstart,'s'))
# print(score)
if w==[]:
score=(2*min(l[0][0],k))-1
if score<0:
score=0
else:
for i in l:
if type(i)==tuple:
x=i[0]
if x<=k:
score+=((2*x))
# print(x,k)
k=k-x
else:
score+=(2*min(x,k))
# print(x,k)
break
else:
if i<=k:
score+=((2*i)+1)
# print(i,k)
k=k-i
else:
score+=(2*k)
# print(i,k)
break
print(score)
| 8 | PYTHON3 |
#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;
vector<pair<int, int> > pontes;
bool lastW = false;
int tam = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W' && !lastW) {
lastW = true;
} else if (s[i] == 'W' && lastW) {
pontes.push_back(make_pair(tam, i));
tam = 0;
}
if (s[i] == 'L' && lastW) {
tam++;
}
}
sort(pontes.begin(), pontes.end());
long long ans = 0;
for (int i = 0; i < pontes.size(); i++) {
if (pontes[i].first <= k) {
k -= pontes[i].first;
for (int j = pontes[i].second - pontes[i].first; j < pontes[i].second;
j++) {
s[j] = 'W';
}
} else {
break;
}
}
if (k > 0) {
for (int i = 1; i < n; i++) {
if (k <= 0) {
break;
}
if (s[i - 1] == 'W' && s[i] != 'W') {
s[i] = 'W';
k--;
}
}
}
if (k > 0) {
for (int i = n - 2; i >= 0; i--) {
if (k <= 0) {
break;
}
if (s[i + 1] == 'W' && s[i] != 'W') {
s[i] = 'W';
k--;
}
}
}
if (k > 0) {
for (int i = 0; i < n; i++) {
if (k <= 0) break;
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
}
ans = 0;
bool hasW = false;
for (int i = 0; i < n; i++) {
if (s[i] == 'W' && !hasW) {
ans += 1;
hasW = true;
} else if (s[i] == 'W' && hasW) {
ans += 2;
}
if (s[i] == 'L') {
hasW = false;
}
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
import io
import os
import sys
import math
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
input = sys.stdin.readline
T = int(input())
for t in range(T):
N, K = map(int, input().split())
S = input().strip()
loss = win = 0
strikes = []
gaps = []
current_win = 0
current_loss = 0
for i, s in enumerate(S):
if s == 'W':
current_win += 1
win += 1
if current_loss:
if len(strikes):
gaps.append(current_loss)
current_loss = 0
else:
current_loss += 1
loss += 1
if current_win:
strikes.append(current_win)
current_win = 0
if current_win:
strikes.append(current_win)
if K >= loss:
print(N*2 - 1)
continue
if win == 0:
print(max(K*2 - 1, 0))
continue
gaps.sort()
ans = 2 * (win + K) - len(strikes)
fixed_gaps = 0
for gap in gaps:
if gap <= K:
fixed_gaps += 1
K -= gap
else:
break
ans += fixed_gaps
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long k;
cin >> k;
string s;
cin >> s;
while (s[0] == 'L') s.erase(s.begin());
while (s[s.size() - 1] == 'L') s.erase(s.end() - 1);
long long m = s.size();
if (m == 0) {
cout << max(2 * min(n, k) - 1, k - k) << "\n";
return;
}
int flag = 0, ans = 0, count = 0;
vector<long long> v;
for (int i = 0; i < m; i++) {
if (s[i] == 'W') {
if (flag == 0) {
ans++;
v.push_back(count);
count = 0;
} else
ans += 2;
flag = 1;
} else {
flag = 0;
count++;
}
}
sort(v.begin(), v.end());
int i = 1;
while (k > 0 && i < v.size()) {
if (k >= v[i])
ans += v[i] * 2 + 1;
else {
ans += k * 2;
k = 0;
break;
}
k -= v[i];
i++;
}
if (k > 0) {
ans += min(k, n - m) * 2;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
cin >> tt;
while (tt--) {
solve();
}
}
| 8 | CPP |
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod=10**9+7
for t in range(int(data())):
n,k=mdata()
s=data()
l=[]
ind=-1
ans=0
a=0
for i in range(n):
if s[i]=='W':
l.append([i-ind-1,ind+1])
ind=i
ans+=1
if i>0 and s[i-1]=='W':
ans+=1
l.append([n-ind-1,ind+1])
a=l.pop(0)
b=[0,0]
if l:
b=l.pop()
l.sort(key=lambda x:x[0])
l=l[::-1]
for i in range(len(l)-1,-1,-1):
if l[i][0]>0:
if l[i][0]<=k:
ans+=2*l[i][0]+1
k-=l[i][0]
if l[i][1]==0:
ans-=1
if l[i][1]+l[i][0]==n:
ans-=1
else:
break
l.pop()
l.append(a)
l.append(b)
for i in l:
if i[0]>0:
if i[0]<=k:
ans+=2*i[0]+1
k-=i[0]
if i[1]==0:
ans-=1
if i[1]+i[0]==n:
ans-=1
elif k:
ans+=2*k
if (i[1]==0 or s[i[1]-1]!='W'):
if i[1]+i[0]==n:
ans-=1
elif s[i[1]+i[0]]!='W':
ans-=1
break
out(ans)
| 8 | PYTHON3 |
import sys
readline = sys.stdin.readline
T = int(readline())
Ans = [None]*T
for qu in range(T):
N, K = map(int, readline().split())
S = [1 if s == 'W' else 0 for s in readline().strip()]
if all(s == 0 for s in S):
Ans[qu] = max(0, 2*K-1)
continue
ans = 0
ctr = 0
st = []
L = []
res = 0
hh = False
for i in range(N):
s = S[i]
if s == 1:
if i == 0 or S[i-1] == 0:
ans += 1
else:
ans += 2
if ctr:
st.append(ctr)
ctr = 0
hh = True
else:
if hh:
ctr += 1
else:
res += 1
res += ctr
st.sort()
J = []
for s in st:
J.extend([2]*(s-1) + [3])
J.extend([2]*res)
Ans[qu] = ans + sum(J[:min(len(J), K)])
print('\n'.join(map(str, Ans)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long power(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;
}
bool cust(pair<long long, pair<long long, long long>> a,
pair<long long, pair<long long, long long>>& b) {
return a.first > b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
int win = 0;
long long ans = 0;
multiset<long long> m;
for (int i = 1; i < n; i++) {
if (s[i - 1] == 'W') {
long long c = 0;
while (i < n && s[i] == 'L') {
c++;
i++;
}
if (c > 0 && i != n) m.insert(c);
}
}
long long los = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') los++;
}
if (los <= k) {
cout << 2 * n - 1 << endl;
continue;
}
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
win = 1;
ans++;
i++;
while (i < n && s[i] == 'W') {
ans += 2;
i++;
}
}
}
for (auto j = m.begin(); j != m.end(); j++) {
if (*j <= k) {
k -= *j;
los -= *j;
ans += ((*j) * 2 + 1);
} else {
ans += (2 * k);
k = 0;
break;
}
}
if (k > 0) {
if (win == 0) ans--;
ans += min(k, los) * 2;
}
cout << ans << endl;
}
}
| 8 | CPP |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
s=input()
l=list(s)
i=0
temp=[]
while(i<n):
if(l[i]=='W' and i+1<n and l[i+1]=='W'):
i+=1
elif(l[i]=='W'):
j=i+1
while(j<n and l[j]=='L'):
j+=1
if(j!=n):
temp.append([j-i-1,i+1,j])
i=j
else:
i+=1
temp.sort()
for i in range(len(temp)):
cur=temp[i]
for j in range(cur[1],cur[2]):
if(k==0):
break
l[j]='W'
k-=1
if(k==0):
break
i=0
while(i<n):
if(k>0):
if(l[i]=='W'):
cur=i+1
while(k>0 and cur<n and l[cur]=='L'):
l[cur]='W'
cur+=1
k-=1
i=cur
else:
i+=1
else:
break
i=n-1
while(i>=0):
if(k>0):
if(l[i]=='W'):
cur=i-1
while(k>0 and cur>=0 and l[cur]=='L'):
l[cur]='W'
cur-=1
k-=1
i=cur
else:
i-=1
else:
break
for i in range(n):
if(k>0):
if(l[i]=='L'):
l[i]='W'
k-=1
else:
break
c=0
if(l[0]=='W'):
c+=1
for i in range(1,n):
if(l[i-1]=='W' and l[i]=='W'):
c+=2
elif(l[i]=='W'):
c+=1
print(c) | 8 | PYTHON3 |
T = int(input())
for t in range(T):
N, K = [int(_) for _ in input().split()]
initK = K
s = input()
nb_l = len([c for c in s if c == 'L'])
current_score = 0
current_nb = 0
current_c = None
loss_group_sizes = []
has_won = False
for c in s:
if c == current_c:
current_nb += 1
if c == 'W':
current_score += 2
continue
if current_c == 'L' and has_won:
loss_group_sizes.append(current_nb)
current_nb = 1
current_c = c
if c == 'W':
current_score += 1
has_won = True
loss_group_sizes = sorted(loss_group_sizes)
i = 0
# print('init score', current_score)
while K > 0 and i < len(loss_group_sizes):
if K >= loss_group_sizes[i]:
current_score += 2*loss_group_sizes[i] + 1
K -= loss_group_sizes[i]
else:
break
i += 1
# print('after groups', current_score, 'left', K)
left_l = nb_l - (initK - K)
if 'W' in s:
current_score += 2 * (min(K, left_l))
else:
current_score += max(0, 2 * (min(K, left_l)) - 1)
print(current_score)
| 8 | PYTHON3 |
import sys
def input():
return sys.stdin.readline().rstrip()
def getMax(n):
if n <= 1:
return n
else :
return ((n*2)-1)
def getPresentScore(len_arr):
countZero = 0
for l in len_arr:
if l == 0:
countZero += 1
return (len(len_arr) - 1 + countZero)
t = int(input())
for i in range(t):
[n,k] = list(map(int,input().split()))
str_inp = input()
str_inp = 'a'+str_inp+'a'
len_arr = list(map(lambda x: len(x),str_inp.split('W')))
w_count = len(len_arr) - 1
l_count = n - w_count
presentScore = getPresentScore(len_arr)
if l_count <= k:
print(getMax(n))
continue
elif w_count == 0:
print(getMax(k))
elif w_count == 1:
print((presentScore+(k*2)))
else :
poss_seg = list(len_arr[1:-1])
bonus = 0
poss_seg.sort()
k_copy = k
for seg in poss_seg:
if seg == 0:
continue
elif seg <= k:
bonus += 1
k -= seg
else :
break
print((presentScore + (k_copy*2) + bonus))
| 8 | PYTHON3 |
def solve(n, k, s):
gaps = []
first_w_index = -1
last_w_index = -1
score = 0
win_streak = 0
for i in range(n):
if s[i] == 'W':
win_streak += 1
if first_w_index == -1:
first_w_index = i
elif i - last_w_index - 1 > 0:
gaps.append(i-last_w_index-1)
last_w_index = i
else:
if win_streak > 0:
score += 2 * win_streak - 1
win_streak = 0
if win_streak > 0:
score += 2*win_streak-1
gaps.sort()
for i, g in enumerate(gaps):
if g <= k:
score += 2*g+1
k -= g
elif k > 0:
score += 2*k
k = 0
break
# k > 0 here means in-between gaps are all filled.
# This includes the case of no in-between gaps.
if k > 0:
# last_w_index >= first_w_index
if first_w_index == -1:
# no win at all, then the optimal is to have k consecutive wins
score += 2*k-1
else:
# the optimal here is to append wins at the begining and ending gaps.
score += 2 * min(k, first_w_index + n-last_w_index-1)
return score
T = int(input())
for _ in range(T):
n, k = map(int, input().split())
s = input()
print(solve(n, k, s))
| 8 | PYTHON3 |
cases = int(input())
for t in range(cases):
n,k = list(map(int, input().split()))
s = input()
fw = s.find('W')
lw = s.rfind('W')
s = list(s)
ls = []
for i in range(fw+1,n):
if s[i]=='L' and s[i-1]=='W':
st = i
elif s[i]=='W' and s[i-1]=='L':
ls.append([i-st,st,i])
ls = sorted(ls)
f = 0
c = 0
for l,i,j in ls:
for m in range(i,j):
if c<k:
s[m]='W'
c+=1
else:
f = 1
break
if f==1:
break
if f==0:
for i in range(lw+1,n):
if c<k:
s[i]='W'
c+=1
else:
f=1
break
if f==0:
for i in range(fw-1,-1,-1):
if c<k:
s[i]='W'
c+=1
else:
f=1
break
out = 0
for i in range(n):
if i==0 and s[i]=='W':
out += 1
elif i>0 and s[i]=='W' and s[i-1]=='L':
out += 1
elif i>0 and s[i]=='W' and s[i-1]=='W':
out += 2
print(out)
| 8 | PYTHON3 |
z,zz=input,lambda:list(map(int,z().split()))
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---##############################
num=int(z())
ans=[]
for _ in range( num ):
n,k=zz()
arr=sorted(map(len,z().strip('L').split('W')))
m=len(arr)+k
while arr and arr[0]<=k:
k-=arr.pop(0)
ans.append((2*min(n,m-1)-len(arr)or 1)-1)
for _ in ans:print(_)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int i, j, k, n, t;
cin >> t;
while (t--) {
cin >> n >> k;
string s, r;
cin >> s;
r = s;
vector<pair<int, int> > a;
int p = 0, q = 0;
for (i = 0; i < n; ++i) {
if (s[i] == 'W') continue;
j = i;
while (j < n and s[i] == s[j]) j++;
if (i == 0)
p = j - i;
else if (j == n)
q = j - i;
else
a.push_back({i, j - 1});
i = j - 1;
}
sort(a.begin(), a.end(), [&](pair<int, int> x, pair<int, int> y) {
return x.second - x.first < y.second - y.first;
});
if (q != 0) a.push_back({n - q, n - 1});
for (auto x : a) {
j = x.first;
while (k and j <= x.second) {
s[j++] = 'W';
k--;
}
}
if (p != 0) {
j = p - 1;
while (j >= 0 and k) {
s[j--] = 'W';
k--;
}
}
int ans = 0;
int prev = 0;
for (i = 0; i < n; ++i) {
if (s[i] == 'W') {
ans += prev + 1;
prev = 1;
} else
prev = 0;
}
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
import sys
import math
from collections import defaultdict,deque
input = sys.stdin.readline
def inar():
return [int(el) for el in input().split()]
def main():
t=int(input())
for _ in range(t):
n,k=inar()
arr=list(input().strip())
ans=0
ind=[]
for i in range(n):
if arr[i]=="W":
ind.append(i)
tup=[]
for i in range(1,len(ind)):
el1=ind[i-1]
el2=ind[i]
t=el2-el1-1
tup.append([t,el1,el2])
tup.sort()
# print(tup)
for i in range(len(tup)):
start=tup[i][1]
end=tup[i][2]
for j in range(start+1,end):
if k==0:
break
if arr[j]=="L":
k-=1
arr[j]="W"
if k==0:
break
if k>0:
if len(ind)==0:
for i in range(n):
if k == 0:
break
if arr[i] == "L":
k -= 1
arr[i] = "W"
else:
for i in range(ind[0]-1,-1,-1):
if k==0:
break
if arr[i]=="L":
k-=1
arr[i]="W"
for i in range(ind[-1]+1,n):
if k==0:
break
if arr[i]=="L":
k-=1
arr[i]="W"
temp=0
for i in range(n):
if arr[i]=="W":
ans+=temp+1
if temp==0:
temp=1
else:
temp=0
print(ans)
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
l=[]
from collections import Counter
for _ in range(int(input())):
n,k=map(int,input().split())
a=list(input())
d=dict(Counter(a))
if "L" not in d:
d["L"]=0
if "K" not in d:
d["K"]=0
if d["L"]<=k:
l.append(1+(n-1)*2)
elif d["L"]==n and k!=0:
l.append(1+2*(k-1))
elif d["L"]==n and k==0:
l.append(0)
else:
s=[]
count=0
for i in range(n):
if a[i]=="L":
count=count+1
else:
if i!=0:
if a[i-1]=="L":
s.append(count)
count=0
if a[0]=="L":
s=s[1:]
s.sort()
sum=0
i=0
flag=1
while k>0 and i<len(s):
k=k-(s[i])
if k<0:
k=k+s[i]
break
else:
sum=sum+2*s[i]+1
i=i+1
if k!=0:
sum=sum+2*k
s=[]
count=0
for i in range(n):
if a[i]=="W":
count=count+1
else:
if i!=0:
if a[i-1]=="W":
s.append(count)
count=0
if a[-1]=="W":
s.append(count)
s1=0
for i in s:
s1=s1+(2*i)-1
l.append(sum+s1)
for i in l:
print(i)
| 8 | PYTHON3 |
"""
Author - Satwik Tiwari .
27th Sept , 2020 - Sunday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
from heapq import *
# from math import gcd, factorial,floor,ceil
from copy import deepcopy
from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O 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")
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)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 10**9+7
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def solve(case):
n,k = sep()
a = list(inp())
ll = []
temp = -1
j = 0
while(j<n):
if(a[j] == 'L'):
curr = 0
i = j
while(i<n and a[i] == 'L'):
curr+=1
i+=1
if(i!=n):
if(j!=0):
# print(j,'===')
ll.append(curr)
else:
temp = curr
j = i+1
else:
j+=1
# print(ll,len(ll))
if(a.count('L') <= k):
print(2*n-1)
return
if(a.count('L') == n):
print(2*k-1 if k>0 else 0)
return
# print('hello')
ll = sorted(ll)
ans = 0
for i in range(len(ll)):
# print(k)
if(k>=ll[i]):
ans+=2*ll[i]+1
k-=ll[i]
else:
ans+=2*k
# k -=ll[i]
k = 0
break
# if(k<0):
# k = 0
# break
if(temp!=-1):
# print('here')
ans+=2*min(k,temp);k-=min(k,temp)
ans+=2*k
f = False
for i in range(n):
if(a[i] == 'L'):
f = False
else:
if(f):
ans +=2
else:
f = True
ans+=1
print(ans)
# testcase(1)
testcase(int(inp()))
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k = map(int,input().split())
l = list(input())
cont,edge = [],[]
last = True
wCnt,lCnt,ans=0,0,0
for i in range(n):
if l[i]=="L":
if wCnt>0:
ans+=wCnt*2-1
wCnt=0
lCnt+=1
else:
if i==lCnt and i:edge.append(lCnt)
elif lCnt>0:cont.append(lCnt)
wCnt+=1
lCnt=0
if lCnt:edge.append(lCnt)
if wCnt:ans+=wCnt*2-1
cont.sort()
edge.sort()
if ans==0:
lCnt = min(k,lCnt)
print(max(lCnt*2-1,0))
continue
for i in cont:
if k==0:break
if k>i:
ans+=2*i+1
k-=i
elif k<i:
ans+=2*k
k=0
else:
ans+=2*i+1
k=0
for i in edge:
if k==0:break
if k>=i:
ans+=i*2
k-=i
else:
ans+=k*2
k=0
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int ans = 0;
string s;
cin >> s;
vector<pair<char, int>> v;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
if (!int(v.size()) || v.back().first != s[i])
v.push_back({s[i], 1});
else
v.back().second++;
}
vector<pair<int, int>> rem;
for (int i = 1, ThxDem = int(v.size()) - 1; i < ThxDem; ++i) {
if (v[i].first == 'L') rem.push_back({v[i].second, i});
}
sort(rem.begin(), rem.end());
for (int i = 0, ThxDem = int(rem.size()); i < ThxDem; ++i) {
if (rem[i].first <= k) {
v[rem[i].second].first = 'W';
k -= rem[i].first;
} else {
int now = k;
v[rem[i].second].second -= k;
pair<char, int> noww = {'W', k};
int off = rem[i].second != int(v.size()) - 1;
v.insert(v.begin() + rem[i].second + off, noww);
k = 0;
break;
}
}
if (v[0].first == 'L') {
if (v[0].second <= k)
v[0].first = 'W', k -= v[0].second;
else if (k) {
int now = k;
v[0].second -= k;
pair<char, int> noww = {'W', k};
v.insert(v.begin() + 1, noww);
k = 0;
}
}
int xx = int(v.size()) - 1;
if (v[xx].first == 'L') {
if (v[xx].second <= k)
v[xx].first = 'W';
else if (k) {
int now = k;
v[xx].second -= k;
pair<char, int> noww = {'W', k};
v.insert(v.begin() + xx, noww);
}
}
char pre = 'L';
for (int i = 0, ThxDem = int(v.size()); i < ThxDem; ++i) {
if (v[i].first == 'L')
pre = v[i].first;
else {
if (pre == 'L')
ans += 2 * v[i].second - 1;
else
ans += 2 * v[i].second;
pre = v[i].first;
}
}
cout << ans << "\n";
}
}
| 8 | CPP |
for _ in range(int(input())):
n,k=map(int, input().split())
s=input()
w=s.count('W')
if s.count('L')<=k:
ans=2*n-1
print(ans)
elif k==0 and w==0:
print(0)
else:
i=0
c1=s.find('W')
c2=s.rfind('W')
if c1==-1:
ans=2*k-1
else:
l=[]
s=s[c1+1:c2]
#print(s)
i=0
c=0
while i<len(s):
if s[i]=='L':
c=1
j=i+1
while j<len(s) and s[j]=='L':
c+=1
j+=1
l.append(c)
i=j
else:
i+=1
l.sort()
#print(l)
i=0
streak=len(l)+1
#print(streak)
k0=k
while i<len(l) and k>0:
if l[i]<=k:
k-=l[i]
streak-=1
i+=1
#print(streak)
if streak==0:
ans=2*(w+k0)-1
else:
ans=2*(w+k0)-streak
#print(w,k)
print(ans)
| 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
# region fastio
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")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# import sys
# sys.setrecursionlimit(5010)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
for _ in range(N()):
n,k = RL()
s = input().strip()
if 'W' not in s:
print(max(0,k*2-1))
else:
t = s.find('W')
l = []
w = []
now = 0
ww = 0
for i in range(t,n):
if s[i]=='W':
if now>0:
l.append(now)
now = 0
ww+=1
else:
if ww>0:
w.append(ww)
ww = 0
now+=1
if ww>0:
w.append(ww)
res = 0
for i in w:
res+=i*2-1
tail = now
l.sort()
# print(l,w,res)
for i in l:
if i>k:
res+=2*k
k = 0
break
else:
k-=i
res+=2*i+1
# print(k,tail,t)
res+=min(k,tail)*2
k = max(0,k-tail)
res+=min(t,k)*2
print(res)
| 8 | PYTHON3 |
def print_arr(arr):
for i, ch in enumerate(arr):
if i == len(arr) - 1:
print(ch)
else:
print(ch, end=' ')
if not arr:
print()
def run(arr):
s = sum(arr)
if s == 0:
print('NO')
elif s < 0:
arr.sort()
print('YES')
print_arr(arr)
else:
arr.sort(reverse=True)
print('YES')
print_arr(arr)
def chess(s, k):
l_count = s.count('L')
if l_count <= k:
return len(s)*2 - 1
interval_count = 1
intervals = []
start = 0
wins = s.count('W') + k
for i in range(len(s)):
if s[i] == 'W':
start = i
break
is_winning = True
curr_lose_size = 0
for i in range(start, len(s)):
if is_winning and s[i] == 'L':
is_winning = False
curr_lose_size += 1
elif not is_winning and s[i] == 'L':
curr_lose_size += 1
elif not is_winning and s[i] == 'W':
is_winning = True
interval_count += 1
intervals.append(curr_lose_size)
curr_lose_size = 0
intervals.sort()
for i in intervals:
k -= i
if k >= 0:
interval_count -= 1
else:
break
return wins*2 - interval_count if wins > 0 else 0
n = int(input())
for _ in range(n):
k = int(input().split()[1])
s = input()
s = list(s)
print(chess(s, k))
| 8 | PYTHON3 |
for bleh in range(int(input())):
a=list(map(int,input().strip().split(" ")))[1]
b=input()
w=b.count("W")
if w==0:
if a>0:
print(2*a-1)
else:
print(0)
else:
w=0
wt=False
lcout=0
if b[0]=="L":
lcout=-1
c=[]
d=[]
for i in b:
if i=="W":
if wt:
w+=2
else:
if lcout>0:
if lcout%2==1:
d.append(lcout)
else:
c.append(lcout)
lcout=0
wt=True
w+=1
else:
if wt:
wt=False
lcout+=2
if lcout>0:
d.append(lcout-1)
c.sort()
d.sort()
for j in c:
if j//2>a:
w+=2*a
a=0
break
else:
w+=j+1
a-=(j//2)
for j in d:
if (j//2+j%2)>a:
w+=2*a
break
else:
w+=j+1
a-=(j//2+j%2)
print(w) | 8 | PYTHON3 |
def solve(n, k, games):
W, L = "W", "L"
if n == 1:
if games[0] == L and k == 0:
return 0
return 1
gl = []
wins = 0
scores = 0
if games[0] == W:
scores += 1
wins += 1
else:
gl.append(1)
for i in range(1, n):
if games[i] == W:
wins += 1
if games[i-1] == W:
scores += 2
else:
scores += 1
else:
if games[i-1] == W:
gl.append(1)
else:
gl[-1] += 1
m = wins + k
if m >= n:
return 2*n-1
if k == 0:
return scores
if wins == 0:
return 2*k-1
if games[0] == L:
gl.pop(0)
if games[-1] == L:
gl.pop()
a = 0
gl.sort()
c = 0
for i in range(len(gl)):
c += gl[i]
if c <= k:
a += 1
else:
break
return scores + a + 2*k
t = int(input())
for i in range(t):
n, k = map(int, input().split())
games = input()
print(solve(n, k, games))
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
ans = 0
init = s.count('L')
for i in range(1, n):
if s[i] == "W" and s[i - 1] == "W":
ans += 2
elif s[i] == "W":
ans += 1
if s[0] == 'W':
ans += 1
if k == 0:
print(ans)
continue
final = []
tmp = s.find('W')
count = 0
for i in range(tmp + 1, n):
if s[i] == 'L':
count += 1
else:
final.append(count)
count = 0
tmp3 = []
for i in final:
if i != 0:
tmp3.append(i)
final = tmp3[:]
final.sort()
i = 0
while k > 0 and i < len(final):
if final[i] <= k:
k -= final[i]
ans += 2 * final[i]
ans += 1
else:
ans += 2 * k
k = 0
i += 1
if 'W' not in s:
if k<=n:
ans += 2 * k - 1
else:
ans += 2 * n - 1
else:
ans += 2 * min(k, (init - sum(final)))
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using pqboro = priority_queue<long long, vector<long long>, less<long long>>;
using pqchoto =
priority_queue<long long, vector<long long>, greater<long long>>;
template <typename T>
string toString(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <typename T>
long long toll(T str) {
stringstream ss;
ss << str;
long long num;
ss >> num;
return num;
}
const int N = 2e5 + 7;
const int M = 1e9 + 7;
const long long inf = 0x7f7f7f7f7f7f7f7f;
void run_for_testcase() {
long long n, m, i, j, k, x;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
long long tot = 0;
long long cnt = 0;
i = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'W') {
break;
}
}
for (; i < n; i++) {
if (s[i] == 'L') {
++cnt;
j = i + 1;
for (; j < n; j++) {
if (s[j] == 'W') {
a.emplace_back(cnt);
cnt = 0;
break;
}
++cnt;
}
i = j - 1;
} else {
++tot;
j = i + 1;
for (; j < n; j++) {
if (s[j] == 'L') {
break;
}
tot += 2;
}
i = j - 1;
}
}
if (tot == 0) {
cout << max(0LL, 2 * k - 1) << endl;
return;
}
sort(a.begin(), a.end());
for (i = 0; i < a.size(); i++) {
if (a[i] <= k) {
k -= a[i];
tot += (1 + (a[i] * 2));
} else {
tot += (k * 2);
cout << tot << endl;
return;
}
}
if (k > 0) {
if (s.front() == 'L') {
cnt = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'L') {
++cnt;
} else
break;
}
if (k > cnt) {
tot += (cnt * 2);
k -= cnt;
} else {
tot += (k * 2);
cout << tot << endl;
return;
}
}
}
if (k > 0) {
if (s.back() == 'L') {
cnt = 0;
for (i = n - 1; i >= 0; i--) {
if (s[i] == 'L')
++cnt;
else
break;
}
tot += (min(k, cnt) * 2);
}
}
cout << tot << endl;
}
int main() {
int tc;
cin >> tc;
while (tc--) run_for_testcase();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long Mod = 1e9 + 7;
const long long inf = 1e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
s += '#';
bool ok = false;
long long front = 0, back = 0;
vector<long long> l;
long long ans = 0;
long long cntL = 0, cntW = 0;
for (long long i = 0; i <= n; i++) {
if (s[i] == 'W')
cntW++;
else {
if (cntW) {
long long x = 1 + (max(0ll, cntW - 1) * 2);
ans += x;
cntW = 0;
}
}
}
debug() << "\033[0;33mLine(" << 118 << ")\033[0m"
<< "\033[1;36m->"
<< "\033[0m"
<< "\033[94m ["
<< "ans"
": "
<< (ans) << "]\033[0m";
for (long long i = 0; i <= n; i++) {
if (s[i] == 'L')
cntL++;
else {
if (!ok) {
front = cntL;
} else if (s[i] == '#') {
back = cntL;
} else if (ok) {
l.push_back(cntL);
}
cntL = 0;
ok = true;
}
}
debug() << "\033[0;33mLine(" << 134 << ")\033[0m"
<< "\033[1;36m->"
<< "\033[0m"
<< "\033[94m ["
<< "front"
": "
<< (front)
<< "]\033[0m"
"\033[94m ["
<< "back"
": "
<< (back) << "]\033[0m";
debug() << "\033[0;33mLine(" << 135 << ")\033[0m"
<< "\033[1;36m->"
<< "\033[0m"
<< "\033[94m ["
<< "l"
": "
<< (l) << "]\033[0m";
sort(l.begin(), l.end());
for (long long i = 0; i < (long long)l.size(); i++) {
if (l[i] == 0) continue;
if (k <= 0) break;
if (k < l[i]) break;
long long x = min(k, l[i]);
ans += (x * 2) + 1;
l[i] -= x;
k -= x;
}
debug() << "\033[0;33mLine(" << 146 << ")\033[0m"
<< "\033[1;36m->"
<< "\033[0m"
<< "\033[94m ["
<< "ans"
": "
<< (ans)
<< "]\033[0m"
"\033[94m ["
<< "k"
": "
<< (k) << "]\033[0m";
for (long long i = 0; i < (long long)l.size(); i++) {
if (k <= 0) break;
long long x = min(k, l[i]);
ans += (x + x);
k -= x;
}
long long x = min(k, front + back);
if (x) {
if (ans > 0) {
ans += (x * 2);
} else {
ans += 2 * x - 1;
}
}
cout << ans << '\n';
}
}
| 8 | CPP |
def main():
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
l = list(input()) # not s!!
segments = []
previous_w = -1
first_w = n; last_w = -1
for c, el in enumerate(l):
if el == "W":
if previous_w != -1 and c != previous_w + 1:
segments.append((c - previous_w - 1, previous_w, c))
previous_w = c
first_w = min(first_w, c)
last_w = max(last_w, c)
segments.sort()
z = 0
while z < len(segments):
current_segment = segments[z]
z += 1
for i in range(min(k, current_segment[0])):
l[current_segment[1] + i + 1] = "W"
k -= current_segment[0]
if k <= 0:
break
if k > 0:
for j in range(min(first_w, k)):
l[first_w - j - 1] = "W"
k -= first_w
if k > 0 and first_w != n:
for x in range(min(n - last_w - 1, k)):
l[last_w + x + 1] = "W"
#print(l, first_w, last_w, segments, k)
total = 0; dub = False
for c, el in enumerate(l):
if el == "W":
total += 1 + dub
dub = el == "W"
print(total)
main() | 8 | PYTHON3 |
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
T = int(input())
ans = [0]*T
for t in range(T):
N, K = map(int, input().split())
S = input().split()[0]
ans[t] = 0
for i,s in enumerate(S):
if i==0:
if s=='W':
ans[t] += 1
elif s=='W':
ans[t] += 1
if S[i-1]=='W':
ans[t] += 1
if 'W' in S:
ans[t] += min(S.count('L'),K)*2
else:
ans[t] += max(min(S.count('L'),K)*2-1,0)
# cnt = 0
# lis = []
# for n in range(N):
# if S[n]=='L':
# cnt += 1
# elif cnt>0:
# cnt = 0
# if len(lis) or S[0]=='L':
# lis.append(cnt)
T = S.split('W')
lis = []
for r in T[1:-1]:
if len(r)>0:
lis.append(len(r))
if len(lis):
# if cnt>0 and (len(lis) or S[0]=='L'):
# lis.append(cnt)
lis.sort()
for l in lis:
if K>=l:
ans[t] += 1
K -= l
print(*ans, sep='\n') | 8 | PYTHON3 |
from bisect import *
from collections import *
from math import *
from heapq import *
from typing import List
from itertools import *
from operator import *
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
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")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
@lru_cache(None)
def fact(x):
if x<2:
return 1
return fact(x-1)*x
@lru_cache(None)
def per(i,j):
return fact(i)//fact(i-j)
@lru_cache(None)
def com(i,j):
return per(i,j)//fact(j)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def binfun(x):
c=1
res=0
for w in arr:
res+=w
if res>x:
res=w
c+=1
return c
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class smt:
def __init__(self,l,r,arr):
self.l=l
self.r=r
self.value=(1<<31)-1 if l<r else arr[l]
mid=(l+r)//2
if(l<r):
self.left=smt(l,mid,arr)
self.right=smt(mid+1,r,arr)
self.value&=self.left.value&self.right.value
#print(l,r,self.value)
def setvalue(self,x,val):
if(self.l==self.r):
self.value=val
return
mid=(self.l+self.r)//2
if(x<=mid):
self.left.setvalue(x,val)
else:
self.right.setvalue(x,val)
self.value=self.left.value&self.right.value
def ask(self,l,r):
if(l<=self.l and r>=self.r):
return self.value
val=(1<<31)-1
mid=(self.l+self.r)//2
if(l<=mid):
val&=self.left.ask(l,r)
if(r>mid):
val&=self.right.ask(l,r)
return val
class UFS:
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
for v in graph[u]:
if v not in d or d[v]>d[u]+graph[u][v]:
d[v]=d[u]+graph[u][v]
heappush(heap,(d[v],v))
return d
'''
import time
s=time.time()
for i in range(2000):
print(0)
e=time.time()
print(e-s)
'''
t=N()
for i in range(t):
n,k=RL()
s=input()
ans=0
for i in range(n):
if s[i]=='W':
if i==0:
ans+=1
else:
ans+=1+(s[i-1]=='W')
if ans==0:
ans=2*k-1 if k else 0
else:
arr=[]
for ch,g in groupby(s):
l=len(list(g))
arr.append((ch,l))
res=0
c=Counter()
for i,(ch,l) in enumerate(arr):
if ch=='L':
if i==0 or i==len(arr)-1:
res+=l
else:
c[l]+=1
for m in sorted(c.keys()):
if k<=m*c[m]:
x,y=divmod(k,m)
ans+=x*(2*m+1)+2*y
k=0
break
else:
k-=m*c[m]
ans+=c[m]*(2*m+1)
if k:
if res:
ans+=min(res,k)*2
k=0
print(ans)
'''
n,m=RL()
arr=[]
for i in range(n):
arr.append(input())
row=[0]*n
col=[0]*m
for i in range(n):
for j in range(m):
if arr[i][j]=='*':
row[i]+=1
col[j]+=1
ans=0
#print(row,col)
for i in range(n):
for j in range(m):
if arr[i][j]=='*':
ans+=(row[i]-1)*(col[j]-1)
print(ans)
'''
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
void solve() {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
long long int idx = 0;
while ((s[idx] == 'L') && (idx < n)) {
idx++;
}
if (idx == n) {
cout << max(0LL, 2 * min(n, k) - 1) << "\n";
return;
}
long long int loss = 0;
long long int win = 0;
long long int ans = 0;
vector<long long int> cnt;
for (long long int i = idx; i < n; i++) {
if (s[i] == 'L') {
loss++;
win = 0;
} else {
if (loss > 0) {
cnt.push_back(loss);
loss = 0;
}
if (win == 0) {
ans += 1;
} else {
ans += 2;
}
win++;
}
}
long long int cntsi = cnt.size();
sort(cnt.begin(), cnt.end());
for (long long int i = 0; i < cntsi; i++) {
if (k < cnt[i]) {
ans += k * 2;
k = 0;
} else {
ans += cnt[i] * 2 + 1;
k = k - cnt[i];
}
if (k == 0) {
break;
}
}
if (k > 0) {
ans = min(ans + k * 2, 2 * n - 1);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
for i in range(int(input())):
n, k = map(int, input().split())
s = input()
wins = s.count('W') + k
if wins >= n:
print(2 * n - 1)
elif wins == k:
print(max(2 * k - 1, 0))
else:
streaks = int(s[0] == 'W') + s.count('LW')
gaps = s.strip('L').replace('W', ' ').strip().split()
for g in sorted(map(len, gaps)):
if g > k:
break
k -= g
streaks -= 1
print(wins * 2 - streaks)
| 8 | PYTHON3 |
nums = int(input().strip())
for _ in range(nums):
n,k = map(int,input().strip().split())
s = input().strip()
lw,rw = s.find("W"),s.rfind("W")
res = cur_num = 0
if lw==rw:
if lw==-1:
res = 2*k-1
else:
res = 2*k+1
res = min(2*len(s)-1,res)
else:
part = []
for i in range(lw,rw+1):
if s[i]=="W":
if i>lw and s[i-1]=="L":
part.append(cur_num)
cur_num = 0
if i>lw and s[i-1]=="W":
res+=2
else:
res+=1
else:
cur_num+=1
if k>=(sum(part)+lw+len(s)-rw-1):
res = 2*len(s)-1
else:
part.sort()
for i in range(len(part)):
if k>=part[i]:
res+=2*part[i]+1
k-=part[i]
else:
break
res+=2*k
print(max(res,0)) | 8 | PYTHON3 |
from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
n,k = map(int,stdin.readline().split())
s = list(stdin.readline()[:-1])
end = 0
if "W" not in s:
print (max(0,2*k-1))
continue
while s[-1] == "L":
end += 1
del s[-1]
s.reverse()
while s[-1] == "L":
end += 1
del s[-1]
q = []
now = []
for i in range(len(s)):
if s[i] == "L":
now.append(i)
else:
for j in now:
q.append((len(now) , j))
now = []
q.sort()
for num,ind in q:
if k <= 0:
break
s[ind] = "W"
k -= 1
ans = min(end,k)*2
for i in range(len(s)):
if s[i] == "W":
if i != 0 and s[i-1] == "W":
ans += 2
else:
ans += 1
print (ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char a[100010];
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n, k;
priority_queue<int, vector<int>, greater<int> > pq;
scanf("%d %d", &n, &k);
scanf("\n%s", a);
int cnt = 0, p = 0, ch = 0, i = 0;
while (a[i] == 'L') {
i++;
}
ch = i;
for (; i < n; i++) {
if (a[i] == 'W' && p != 0) {
cnt += 1;
pq.push(p);
p = 0;
} else if (a[i] == 'W')
cnt += i == ch ? 1 : 2;
else
p++;
}
if (a[n - 1] == 'L') ch += p;
while (!pq.empty() && k > 0) {
int c = pq.top();
pq.pop();
if (k >= c) {
cnt += 2 * c + 1;
k -= c;
} else {
cnt += 2 * k;
k = 0;
}
}
if (ch == n && k > 0)
cnt += 2 * (k > ch ? ch : k) - 1;
else if (k > 0)
cnt += 2 * (k > ch ? ch : k);
printf("%d\n", cnt);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const long long mod = 1e9 + 7;
int CASE = 1;
const int mxn = 1e5 + 1;
const long long infll = 1e18;
const int infi = 1e9;
bool prime(long long n) {
if (n <= 1) return false;
if (n == 2 or n == 3) return true;
if (n % 2 == 0 or 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;
}
long long __gcd(long long a, long long b) { return !b ? a : __gcd(b, a % b); }
long long power(long long a, long long b) {
long long x = a, res = 1, p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
void solve() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<pair<int, int> > pos;
char pre = 'L';
if (s.find('W') == -1) {
cout << m * 2 - 1 * (m > 0) << '\n';
return;
}
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
if (pre == 'L') {
pre = 'W';
pos.push_back(make_pair(i, i));
} else {
pos.back().second++;
}
} else {
pre = 'L';
}
}
vector<pair<int, int> > v;
for (int i = 0; i < pos.size() - 1; i++) {
v.push_back(
make_pair(pos[i].second + 1, pos[i + 1].first - pos[i].second - 1));
}
sort(v.begin(), v.end(),
[](pair<int, int> a, pair<int, int> b) { return a.second < b.second; });
for (auto x : v) {
if (m >= x.second) {
for (int i = x.first; s[i] == 'L'; i++) s[i] = 'W', m--;
} else {
for (int i = x.first; m > 0; i++, m--) s[i] = 'W';
}
}
int index = s.find('W') - 1;
while (index >= 0 && s[index] == 'L' && m > 0) {
s[index] = 'W';
m--;
index--;
}
index = s.find_last_of('W') + 1;
while (index < n && s[index] == 'L' && m > 0) {
s[index] = 'W';
m--;
index++;
}
int ans = 0;
pre = 'C';
for (int i = 0; i < n; i++) {
if (s[i] == 'L')
pre = 'L';
else {
if (pre == 'W')
ans += 2;
else
ans++, pre = 'W';
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 8 | CPP |
# from bisect import bisect_left
TC = int(input())
for tc in range(TC):
N, K = map(int, input().split())
S = list(input())
w = 0
l = []
rw = 0
rl = 0
start = 0
for s in S:
if s == 'W':
if rl > 0:
if w > 0:
l.append(rl)
else:
start = rl
rl = 0
if rw > 0:
rw += 2
else:
rw = 1
else:
if rw > 0:
w += rw
rw = 0
rl += 1
if rl > 0:
start += rl
if rw > 0:
w += rw
l.sort()
# print('w', w)
for lc in l:
if K >= lc:
w += 2 * lc + 1
K -= lc
else:
w += 2 * K
K = 0
break
# print('w2', w)
if K > start:
if w > 0:
w += start * 2
else:
w = start * 2 - 1
else:
if w > 0:
w += K * 2
elif K > 0:
w = K * 2 - 1
print(w)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const bool TEST = false;
const long double PI = 3.1415926535897932384626433832795;
const int inf = 2147483647;
const long long infll = 9223372036854775807;
const int mod = 1000000007;
long long max(int a, long long b) { return max((long long)a, b); }
long long min(int a, long long b) { return min((long long)a, b); }
long long min(long long a, int b) { return min(a, (long long)b); }
long long max(long long a, int b) { return max(a, (long long)b); }
long long dx[] = {0, 0, 1, -1};
long long dy[] = {1, -1, 0, 0};
long long dxk[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long dyk[] = {1, -1, 0, 0, 1, -1, 1, -1};
bool isint(double d) { return (d == floor(d)); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long ipow(long long a, long long b) {
if (a == 1 || b == 0) return 1;
long long r = 1;
for (long long i = 1; i <= b; i++) r *= a;
return r;
}
long long power(long long a, long long b) {
if (a == 1 || b == 0) return 1;
long long c = power(a, b / 2);
long long res = (c * c) % mod;
;
if (b % 2) res = (res * (a % mod)) % mod;
return res;
}
bool isPrime(int n) {
if (n == 1) return false;
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
string toBase(int n, int b) {
string oval = "";
while (n >= 1) {
if (n % b < 10)
oval += to_string(n % b);
else
oval += 'A' + (n % b - 10);
n /= b;
}
reverse(oval.begin(), oval.end());
return oval;
}
void Solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> fasele;
int l = -1;
for (long long i = 0; i <= s.length() - 1; i++) {
if (s[i] == 'W') {
if (i - l > 1 && l != -1) fasele.push_back(i - l - 1);
l = i;
}
}
long long score = s[0] == 'W';
for (long long i = 1; i <= s.length() - 1; i++) {
if (s[i] == 'W') {
if (s[i - 1] == 'W')
score += 2;
else
score += 1;
}
}
sort(fasele.begin(), fasele.end());
for (long long i = 0; i <= (int)fasele.size() - 1; i++)
if (fasele[i] <= k) {
k -= fasele[i];
score += fasele[i] * 2 + 1;
} else if (k > 0) {
score += k * 2;
k = 0;
} else
break;
if (k > 0) {
int first = -1, last = -1;
for (long long i = 0; i <= s.length() - 1; i++)
if (s[i] == 'W') {
first = i;
break;
}
for (long long i = s.length() - 1; i >= 0; i--)
if (s[i] == 'W') {
last = i;
break;
}
if (first != -1) {
score += min(k, (s.length() - last - 1)) * 2;
k -= s.length() - last - 1;
if (k > 0) score += min(k, first) * 2;
} else {
score += k * 2 - 1;
}
}
cout << score << '\n';
}
int main() {
if (!TEST) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int t;
cin >> t;
while (t--) Solve();
if (TEST) {
cout << '\n';
system("pause");
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, m = map(int, input().split())
s = ' ' + input()
q = s.count('L')
if q <= m:
print(max(0, 2 * n - 1))
elif q == len(s) - 1:
print(max(0, 2 * m - 1))
else:
x = 0
y = 0
C = []
for i in range(1, len(s)):
if s[i - 1] == 'W' and s[i] == 'L':
x = 1
elif s[i - 1] == 'L' and s[i] == 'L' and x != 0:
x += 1
elif s[i] == 'L':
y += 1
elif s[i - 1] == 'L' and s[i] == 'W':
if x != 0:
C.append(x)
x = 0
if x != 0:
y += int(x)
#print(C, y)
C.sort()
Ans = 0
#print(C)
for i in range(len(C)):
if m >= C[i]:
Ans += C[i] * 2 + 1
m -= C[i]
#print(Ans)
Ans += m * 2
#print(Ans)
for i in range(1, len(s)):
if s[i] == 'W':
if s[i - 1] == 'W':
Ans += 2
else:
Ans += 1
print(Ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
bool local = false;
using namespace std;
template <class T>
void print(T v) {
cout << ((int)(v).size()) << "\n";
for (auto x : v) cout << x << ' ';
cout << "\n";
};
template <class T>
void print1(T v) {
cout << ((int)(v).size()) << "\n";
for (auto x : v) cout << x + 1 << ' ';
cout << "\n";
};
template <class T1, class T2>
ostream &operator<<(ostream &o, pair<T1, T2> x) {
return o << x.first << ' ' << x.second;
}
template <class T1, class T2>
istream &operator>>(istream &o, pair<T1, T2> &x) {
return o >> x.first >> x.second;
}
template <class T>
ostream &operator<<(ostream &o, vector<T> &x) {
for (auto &el : x) o << el << ' ';
return o;
}
template <class T>
istream &operator>>(istream &o, vector<T> &x) {
for (auto &el : x) o >> el;
return o;
}
template <class T1, class T2>
pair<T1, T2> operator+(pair<T1, T2> a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
return a;
}
template <class T1, class T2>
pair<T1, T2> operator-(pair<T1, T2> a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
template <class T1, class T2>
void operator+=(pair<T1, T2> &a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
}
template <class T1, class T2>
void operator-=(pair<T1, T2> &a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
}
int nint() {
int x;
cin >> x;
return x;
}
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
mt19937 rnd(0);
int rand(int n) { return rnd() % n; }
int rand(int l, int r) { return rnd() % (r - l + 1) + l; }
const int mod = 1000000000 + 7;
void initIO() {
if (local) {
freopen("input.txt", "r", stdin);
srand((int)time(0));
rnd.seed((int)time(0));
} else {
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
};
}
}
void solve();
void precalc();
int TID;
signed main() {
initIO();
int tc = 1;
cin >> tc;
precalc();
for (int tt = 0; tt < (tc); tt++) {
TID = tt;
solve();
}
if (local)
cout << "\n"
<< "time = " << getTime() << "\n";
}
void precalc() {}
int n;
int m;
void solve() {
cin >> n >> m;
string s;
cin >> s;
vector<pair<int, int> > v;
for (int i = 0; i < (n - 1); i++)
if (s[i] == 'W' && s[i + 1] == 'L') {
int l = i + 1;
int r = i + 1;
while (r < n && s[r] == 'L') r++;
if (r < n) v.emplace_back(make_pair(l, r - 1));
}
sort(v.begin(), v.end(), [](pair<int, int> a, pair<int, int> b) {
return a.second - a.first < b.second - b.first;
});
for (pair<int, int> o : v) {
int l = o.first;
int r = o.second;
if (m >= r - l + 1) {
for (int i = l; i <= r; i++) s[i] = 'W';
m -= r - l + 1;
}
}
for (int i = 1; i < n; i++)
if (s[i] == 'L' && s[i - 1] == 'W' && m) {
m--;
s[i] = 'W';
}
for (int i = (n - 1) - 1; i >= 0; i--)
if (s[i] == 'L' && s[i + 1] == 'W' && m) {
m--;
s[i] = 'W';
}
for (int i = 0; i < (((int)(s).size())); i++)
if (s[i] == 'L' && m) {
m--;
s[i] = 'W';
};
;
int ans = 0;
for (int i = 0; i < (((int)(s).size())); i++) {
if (s[i] == 'W') ans += 1 + (s[i - 1] == 'W');
}
cout << ans << "\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
string s;
cin >> n >> k >> s;
int ans = 0;
list<pair<int, int>> a;
int i = 0;
while (i < n) {
int l = 0, w = 0, f1 = 0, f2 = 0;
while (i < n && s[i] == 'L') f1 |= (i == 0), f2 |= (i == n - 1), ++i, ++l;
while (i < n && s[i] == 'W') ++i, ++w;
int y = f1 + f2;
if (l) a.push_back(make_pair(y, l));
if (w) ans += 2 * w - 1;
}
a.sort();
while (k && a.size()) {
int y = a.front().first;
int l = a.front().second;
int m = min(l, k);
if (y == 0 && m == l) ans += 2 * m + 1;
if (y == 0 && m < l) ans += 2 * m;
if (y == 1) ans += 2 * m;
if (y == 2) ans += 2 * m - 1;
k -= m;
a.pop_front();
}
cout << ans << "\n";
}
}
| 8 | CPP |
''' ===============================
-- @uthor : Kaleab Asfaw
-- Handle : kaleabasfaw2010
-- Bio : High-School Student
==============================='''
# Fast IO
import sys
import os
from io import BytesIO, IOBase
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")
# Others
# from math import floor, ceil, gcd
# from decimal import Decimal as d
mod = 10**9+7
def lcm(x, y): return (x * y) / (gcd(x, y))
def fact(x, mod=mod):
ans = 1
for i in range(1, x+1): ans = (ans * i) % mod
return ans
def arr2D(n, m, default=0):
lst = []
for i in range(n): temp = [default] * m; lst.append(temp)
return lst
def sortDictV(x): return {k: v for k, v in sorted(x.items(), key = lambda item : item[1])}
def solve(n, k, lst):
lCnt = lst.count("L")
wCnt = "W" in lst
prescore = 0
for i in range(n):
if lst[i] == "W":
if i != 0 and lst[i-1] == "W": prescore += 2
else: prescore += 1
# print("Prescore", prescore)
# got = False
# cnt = 0
# cnt1 = 0
# ind = -1
# for i in range(n):
# if not got and lst[i] == "L":
# cnt1 += 1
# if got and lst[i] == "L":
# cnt += 1
# if lst[i] == "W":
# got = True
# if got and lst[i] == "L" and ind == -1:
# ind = i
# print("cnt", cnt, cnt1)
# minn = min(cnt, k)
# prescore += (2 * minn)
# cnt -= minn
# k -= minn
# print("score:", prescore, ind)
# for i in range(ind, n):
# if i != n-1 and lst[i] == "L" and lst[i+1] == "W" and minn > 0:
# prescore += 1
# print("minn", i, prescore, minn)
# if lst[i] == "L":
# minn -= 1
# print("score1:", prescore)
# if k > 0:
# prescore += 2 * (min(k, cnt1-1)) + 1
# if wCnt:
# prescore += 1
# return prescore
ans = []
got = False
cnt = 0
for i in range(n):
if got:
if lst[i] == "L":
cnt += 1
else:
ans.append(cnt)
cnt = 0
if lst[i] == "W":
got = True
ans = sorted(ans)
ind = 0
ans += [1]
for i in range(len(ans)+1):
if ans[i] != 0:
ind = i
break
ans = ans[ind:][:-1]
# print(ans)
i = 0
while i < len(ans) and k >= ans[i]:
prescore += ans[i] * 2 + 1
k -= ans[i]
lCnt -= ans[i]
i += 1
# print("Asdas", i, len(ans), k)
ind1 = i
ind2 = 0
ans1 = []
got = False
cnt1 = 0
for i in range(n):
if got:
if lst[i] == "L":
cnt1 += 1
elif cnt1 != 0:
ans1.append(cnt1)
cnt1 = 0
if len(ans1) == ind1:
# print("sada", ans, ind1)
ind2 = i
break
if lst[i] == "W":
got = True
ind3 = ind2
for i in range(ind2, n):
if lst[i] == "L":
ind3 = i
break
cntAft = 0
if wCnt:
for i in range(ind3, n):
if lst[i] == "L":
cntAft += 1
# print("ind2", ind2, ind1)
# print("Score1", prescore)
# cntAft = 0
# if wCnt:
# for i in range(n-1, -1, -1):
# if lst[i] == "W": break
# else:
# cntAft += 1
cntBef = lCnt - cntAft
# print("Score2", prescore, lCnt, cntAft, cntBef)
if k > 0:
prescore += 2 * min(cntAft, k)
k -= min(cntAft, k)
# print("kk", k)
if k > 0:
prescore += 2*min(k-1, cntBef-1) + 1
if wCnt:
prescore += 1
# print("Score3", prescore, lCnt, k)
return prescore
for _ in range(int(input())): # Multicase
n, k = list(map(int, input().split()))
lst = input()
print(solve(n, k, list(lst)))
# print()
# get somebody break ur heart, I just want that | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_game = 100000;
int a[100000 + 10];
int mid[100000 + 10];
char s[100000 + 10];
int main() {
int T;
scanf("%d", &T);
while (T--) {
memset(a, 0, sizeof(a));
memset(mid, 0, sizeof(mid));
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
int p = 1, tot = 1;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
a[p] = tot;
continue;
}
if (s[i] == s[i + 1])
tot++;
else {
a[p] = tot;
tot = 1;
p++;
}
}
if (p == 1 && s[0] == 'L') {
int cnt = min(k, n);
cout << max(cnt * 2 - 1, 0) << endl;
continue;
}
int ans = 0, t = 0, sum = 0;
if (s[0] == 'W') {
for (int i = 1; i <= p; i++) {
if (i % 2)
ans += a[i] * 2 - 1;
else {
mid[++t] = a[i];
sum += a[i];
}
}
} else {
for (int i = 1; i <= p; i++) {
if (i % 2 == 0)
ans += a[i] * 2 - 1;
else
sum += a[i];
if (i >= 3 && i % 2) mid[++t] = a[i];
}
}
if (s[n - 1] == 'L' && p != 1) t--;
if (k >= sum) {
cout << 2 * n - 1 << endl;
continue;
}
sort(mid + 1, mid + (t + 1));
for (int i = 1; i <= t && k >= mid[i]; i++) {
ans += 2 * mid[i] + 1;
k -= mid[i];
sum -= mid[i];
}
if (k > 0 && sum > k) ans += k * 2;
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n,k = map(int,input().split())
kCpy = k
s = input()
WCnt = 0
LCnt = 0
LSegment = []
cnt = 0
for elem in s:
if elem == "W":
LSegment.append(cnt)
cnt = 0
WCnt += 1
else:
cnt += 1
LCnt += 1
if not LSegment:
print(max(2 * k - 1,0))
else:
WBreaker = sorted(LSegment[1:])
if LCnt <= k:
print(2 * n - 1)
else:
broken = 0
for elem in WBreaker:
if k >= elem:
k -= elem
broken += 1
else:
break
print(max(2 * (WCnt + kCpy) - len(WBreaker) + broken - 1,0))
# region fastio
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")
# endregion
if __name__ == "__main__":
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char a[130000];
struct gg {
int x, y, z;
} b[130000];
int cmp(gg p, gg q) { return p.z < q.z; }
void solve() {
int n, m;
cin >> n >> m;
cin >> a;
int l = 0;
int p = 0, q = 0, o = 0;
for (int i = 0; i < n; i++)
if (a[i] == 'W') {
p = i;
o = i;
break;
}
for (int i = 0; i < n; i++) {
if (a[i] == 'W') {
q = i;
b[l].x = p;
b[l].z = q - p - 1;
b[l++].y = q;
p = q;
}
}
sort(b, b + l, cmp);
for (int i = 0; i < l && m > 0; i++) {
int gg = b[i].x, hh = b[i].y;
for (int j = gg + 1; j < hh && m > 0; j++)
if (a[j] == 'L') {
a[j] = 'W';
m--;
}
}
for (int i = o; i >= 0 && m > 0; i--)
if (a[i] == 'L') {
a[i] = 'W';
m--;
}
for (int i = q; i < n && m > 0; i++)
if (a[i] == 'L') {
a[i] = 'W';
m--;
}
int s = 0;
for (int i = 0; i < n; i++)
if (a[i] == 'W') {
if (i == 0 || a[i - 1] != 'W')
s++;
else
s += 2;
}
printf("%d\n", s);
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 8 | CPP |
# -*- coding: utf-8 -*-
t = int(input().replace('\n', ''))
for i in range(t):
line1 = list(map(int, input().replace('\n', '').split(' ')))
n = line1[0]
k = line1[1]
s = list(input().replace('\n', ''))
wins, losses, gap_wins = 0, 0, 0
losses_gaps_len = []
for i in range(n):
if s[i] == 'W':
if i==0 or s[i-1]=='L':
gap_wins += 1
wins += 1
else:
losses += 1
if i==0 or s[i-1]=='W':
losses_gaps_len.append(0)
losses_gaps_len[-1]+=1
if k > losses:
print(2*n-1)
continue
if wins==0:
if k==0:
print(0)
else:
print(2*k-1)
continue
inf = float('inf')
if s[0] == 'L':
losses_gaps_len[0] = inf
if s[n-1] == 'L':
losses_gaps_len[-1] = inf
sorted_losses_gaps_len = sorted(losses_gaps_len)
wins += k
for i in range(len(sorted_losses_gaps_len)):
if sorted_losses_gaps_len[i] > k:
break
else:
gap_wins -= 1
k -= sorted_losses_gaps_len[i]
print(2*wins - gap_wins)
| 8 | PYTHON3 |
import io
import os
import sys
import math
input = sys.stdin.readline
mod = 10**9 + 7
t = int(input())
for i in range(t):
x,y = list(map(int, input().split()))
arr = list(input().rstrip())
c = 0
w = 0
seg = []
score = 0
left = 0
for i in range(len(arr)):
if arr[i]=='W':
if i>0 and arr[i-1]=='W':
score += 2
else:
score += 1
if c!=0 and w!=0:
seg.append(c)
c = 0
w += 1
else:
c += 1
left += 1
seg.sort()
ans = 0
for el in seg:
if y>=el and left>=el:
score += el*2 + 1
y -= el
left -= el
#print(score, y, left)
kg = min(y, left)
if arr.count('W') == 0:
print(max(0,kg*2 - 1))
else:
print(max(0,score + 2*kg)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k, temp;
cin >> n >> k;
temp = k;
string s;
cin >> s;
int ans = 0;
if (s[0] == 'W') ans++;
for (int i = 1; i < n; i++) {
if (s[i] == 'W' && s[i - 1] == 'W')
ans += 2;
else if (s[i] == 'W')
ans++;
}
int cnt = 0, flag = 0;
vector<int> v;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
if (cnt && flag) v.push_back(cnt);
cnt = 0;
flag = 1;
} else {
cnt++;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (k >= v[i]) {
ans += (2 * v[i] + 1);
k -= v[i];
} else {
ans += (2 * k);
k = 0;
break;
}
}
if (k > 0) {
for (int i = 0; i < n; i++) {
if (k == 0 || s[i] == 'W') break;
s[i] = 'W';
ans += 2;
k--;
}
for (int i = n - 1; i >= 0; i--) {
if (k == 0 || s[i] == 'W') break;
ans += 2;
k--;
}
}
if (flag == 0 && temp != 0) ans--;
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
from collections import Counter as C
# from operator import itemgetter
# from math import ceil,sqrt,gcd,factorial,comb
# from collections import deque
# from collections import defaultdict as dd
# d=dd(lambda:0)
# from sys import stdin
# stdin.readline
def mp():return map(int,input().split())
def it():return int(input())
for _ in range(it()):
n,k=mp()
l=list(input())
c=C(l)
ans=0
if c['L']<=k:
ans=2*n-1
print(ans)
elif "W" not in l:
print(max((min(k,n)*2)-1,0))
else:
sm=c['W']
v=[]
indx=l.index("W")
for i in range(indx+1,n):
if l[i]=='W':
v.append(i-indx-1)
indx=i
v.sort()
for i in v:
if k>=i:
sm+=(2*i+1)
k-=i
if k>0:
sm+=(2*k)
print(sm)
| 8 | PYTHON3 |
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=[]
conswins=[]
currconsgaps=0
currconswins=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
ps=s
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)
currconswins+=1
currconsgaps=0
else:
if currconswins>0:
conswins.append(currconswins)
currconswins=0
currconsgaps+=1
if currconsgaps>0:
consgaps.append(currconsgaps)
if currconswins>0:
conswins.append(currconswins)
# 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 |
for _ in range(int(input())):
n,k=map(int,input().split())
l=sorted(map(len,input().strip('L').split('W')))
m=len(l)-1+k
while l and l[0]<=k:k-=l.pop(0)
print((2*min(n,m)-len(l) or 1)-1)
| 8 | PYTHON3 |
t=int(input())
for i in range(0,t):
n,m=list(map(int,input().split()))
z=input()
a=[z[j] for j in range(0,n)]
s=0
cw=0
q=0
b=[]
d=[]
for j in range(0,n):
if(a[j]=='W'):
cw=cw+1
b.append(j)
if(q==1):
s=s+2
if(q==0):
s=s+1
q=1
else:
q=0
g=n-cw
if(m==0):
print(s)
continue
if(cw==0):
print(2*m-1)
continue
elif(g<=m):
s=1+2*(n-1)
elif(g>m):
le=len(b)
for j in range(1,le):
c=b[j]-b[j-1]-1
if(c>0):
d.append(c)
d.sort()
le=len(d)
for j in range(0,le):
if(d[j]<=m):
s=s+2*(d[j])+1
m=m-(d[j])
else:
break
s=s+2*(m)
print(s) | 8 | PYTHON3 |
t = int(input())
for ii in range(t):
n, k = map(int, input().split())
s = input()
a = [0]*n
for i in range(n):
if s[i] == "W":
if i == 0:
a[i] = 1
elif a[i-1] != 0:
a[i] = 2
else:
a[i] = 1
stretch = []
extras = []
count = 0
index = None
for i in range(n):
if a[i] == 0:
if index == None:
index = i
count+=1
else:
if index is not None:
if index == 0:
extras.append((count, index))
else:
stretch.append((count, index))
count = 0
index = None
if a[-1] == 0:
extras.append((count, index))
stretch.sort()
extras.sort()
cnt = 0
ind = 0
# print(stretch)
while (cnt < k and ind<len(stretch)):
inti = stretch[ind][1]
while (cnt<k and inti<n):
if a[inti] == 0:
a[inti] = 1
inti+=1
cnt+=1
else:
break
ind+=1
# print(extras)
ind = 0
while (cnt < k and ind<len(extras)):
inti = extras[ind][1]
if inti != 0:
while (cnt<k and inti<n):
if a[inti] == 0:
a[inti] = 1
inti+=1
cnt+=1
else:
break
else:
while (inti < n and a[inti] == 0):
inti+=1
if inti == n:
inti = n-1
if a[inti] != 0:
inti -= 1
while (cnt<k and inti>-1):
if a[inti] == 0:
a[inti] = 1
inti-=1
cnt+=1
else:
break
ind+=1
for i in range(n):
if a[i] != 0:
if i == 0:
pass
elif a[i-1] != 0:
a[i] = 2
print(sum(a)) | 8 | PYTHON3 |
naborov = int(input())
ks = []
sets = []
for _ in range(naborov):
ks.append(int(input().split()[1]))
sets.append(input())
import collections as clc
def count(ss):
col = clc.Counter()
if s[0] == 'W':
res = 1
prev = 0
first = 0
else:
res = 0
prev = None
for i in range(1, len(ss)):
if ss[i] == 'W':
if ss[i-1] == 'W':
res += 2
else:
res += 1
if prev == None:
first = i
elif prev < i - 1:
col[i-1-prev] += 1
prev = i
last = i-prev
return (res, col, first, last)
def treat(ss, k):
col = clc.Counter(ss)
if col['L'] <= k:
return (len(ss)*2-1)
elif col['W'] == 0:
return (max(0, 2*k-1))
res, col, first, last = count(s)
for d in sorted(col.keys()):
if d*col[d] <= k:
k -= d*col[d]
res += (d*2+1)*col[d]
else:
t, k = divmod(k, d)
res += (d*2+1)*t
break
res += k*2
return(res)
for s, k in zip(sets, ks):
print(treat(s, k)) | 8 | PYTHON3 |
def score(s):
rv=0
for z in range(len(s)):
if s[z]=='W':
if z==0:
rv+=1
else:
if s[z-1]=='W':
rv+=2
else:
rv+=1
return rv
for _ in range(int(input())):
n,k=map(int,input().split())
s=list(input())
cl=s.count('L')
if k==0:
print(score(s))
elif k>=cl:
print((n-1)*2+1)
elif cl==n:
print((k-1)*2+1)
else:
iidx=-1
eidx=-1
for z in range(n):
if s[z]=='W':
iidx=z
break
for z in range(n-1,-1,-1):
if s[z]=='W':
eidx=z
break
if iidx==eidx:
print((k*2)+1)
else:
count=0
ans=[]
for z in range(iidx,eidx+1):
if s[z]=='L':
count+=1
else:
if count:
ans.append((count,z-count))
count=0
if count:
ans.append((count,eidx+1-count));
ans.sort()
for z in ans:
if not k:
break
mini=min(k,z[0])
k-=mini
for x in range(mini):
s[x+z[1]]='W'
while k and eidx+1<n:
s[eidx+1]='W'
eidx+=1
k-=1
while k and iidx-1>-1:
s[iidx-1]='W'
iidx-=1
k-=1
print(score(s))
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k = map(int,input().split())
s = list(input().strip())
from collections import defaultdict
mp = defaultdict(list)
i = 0
while i<n and s[i]=="L":
i+=1
cnt = 0
lst = i
while i<n:
if s[i]=="L":
cnt+=1
else:
if cnt:
mp[cnt].append(lst)
cnt = 0
lst = i+1
i+=1
for i in sorted(mp.keys()):
for idx in mp[i]:
j = idx
while j< n and s[j]=="L" and k>0:
s[j] = "W"
j+=1
k-=1
if k<=0:
break
if k<=0:
break
if k<=0:
break
i =0
mp2 = []
# while i<n and s[i]=="L":
# i+=1
cnt = 0
res = 0
while i<n:
if s[i]=="W":
cnt+=1
else:
if cnt:
res+= 1+ 2*(cnt-1)
mp2.append(cnt)
cnt = 0
i+=1
if cnt:
res+=1+2*(cnt-1)
mp2.append(cnt)
# print(mp2)
if "W" in s:
res += max(0,2*min(s.count("L"),k))
pass
else:
res += max(0,2*min(s.count("L"),k)-1)
pass
# print("".join(s))
print(res)
| 8 | PYTHON3 |
t=int(input())
for i in range(t):
n,k=map(int,input().split())
s=[]
w=input()
for j in w:
s.append(j)
p=k
res=[]
j=0
while(j<n):
if s[j]=="W":
res.append(j)
j+=1
if len(res)==0:
j=0
while(j<n):
if p==0:
break
s[j]="W"
p+=-1
j+=1
elif len(res)==1:
j=res[0]-1
while(j>=0):
if p==0:
break
s[j]="W"
p+=-1
j+=-1
j=res[0]+1
while(j<n):
if p==0:
break
s[j]="W"
p+=-1
j+=1
else:
req=[]
j=1
while(j<len(res)):
req.append([res[j]-res[j-1],res[j-1],res[j]])
j+=1
req.sort()
l=0
while(l<len(req)):
if p==0:
break
j=req[l][1]+1
while(j<req[l][2]):
if p==0:
break
s[j]="W"
p+=-1
j+=1
l+=1
j = res[0] - 1
while (j >= 0):
if p == 0:
break
s[j] = "W"
p += -1
j += -1
j = res[-1] + 1
while (j < n):
if p == 0:
break
s[j] = "W"
p += -1
j += 1
j=1
ans=0
if s[0]=="W":
ans=1
while(j<n):
if s[j]=="W" and s[j]==s[j-1]:
ans+=2
elif s[j]=="W":
ans+=1
j+=1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 10e-9;
const int INF = 1e9 + 5;
const long long INFLL = (long long)INF * (long long)INF;
const long long MOD = 1e9 + 7;
const long double PI = 3.14159265358979323846;
struct HASH {
size_t operator()(const pair<int, int> &x) const {
return hash<long long>()(((long long)x.first) ^
(((long long)x.second) << 32));
}
};
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '[';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "]";
}
void _print() { cerr << "\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
struct Offset {
set<long long> s;
long long delta;
long long getMinimum() { return (*s.begin()) + delta; }
long long getMaximum() { return (*s.rbegin()) + delta; }
void increase(long long x) { delta += x; }
void add(long long x) { s.insert(x - delta); }
void remove(long long x) { s.erase(x - delta); }
bool contains(long long x) { return s.count(x - delta) != 0; }
};
long long solve(int n, int k, string s) {
int wins = 0, losses = 0;
vector<pair<int, int>> w, l;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
wins++;
if (losses) {
l.push_back(make_pair(i - losses, losses));
losses = 0;
}
} else {
losses++;
if (wins) {
w.push_back(make_pair(i - wins, wins));
wins = 0;
}
}
}
if (losses) {
}
if (wins) {
w.push_back(make_pair(n - wins, wins));
}
sort(l.begin(), l.end(), [](const pair<int, int> l, const pair<int, int> r) {
return l.second < r.second;
});
int score = 0;
int first_pos = -1;
for (int i = 0; i < l.size(); i++) {
if (l[i].first == 0) {
first_pos = i;
continue;
}
if (l[i].second <= k) {
for (int j = l[i].first; j < l[i].first + l[i].second; j++) {
s[j] = 'W';
}
k -= l[i].second;
} else {
for (int j = l[i].first; j < l[i].first + k; j++) {
s[j] = 'W';
}
k = 0;
break;
}
}
if (k > 0 && losses) {
int pos = n - losses;
int c = k;
for (int j = pos; j < min(pos + c, n); j++) {
s[j] = 'W';
k--;
}
}
if (k > 0 && first_pos != -1) {
for (int j = l[first_pos].second; j >= max(0, l[first_pos].second - k);
j--) {
s[j] = 'W';
}
}
if (s[0] == 'W') {
score++;
}
for (int i = 1; i < n; i++) {
if (s[i - 1] == 'W' && s[i] == 'W') {
score += 2;
} else if (s[i] == 'W') {
score += 1;
}
}
return score;
}
long long brute(int n, int k, string s) {
vector<int> z;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
z.push_back(i);
}
}
int ans = -1;
for (int mask = 0; mask < (1 << z.size()); mask++) {
if (__builtin_popcount(mask) <= k) {
string cop = s;
for (int i = 0; i < z.size(); i++) {
if (mask & (1 << i)) {
cop[z[i]] = 'W';
}
}
int score = 0;
if (cop[0] == 'W') {
score++;
}
for (int i = 1; i < n; i++) {
if (cop[i - 1] == 'W' && cop[i] == 'W') {
score += 2;
} else if (cop[i] == 'W') {
score += 1;
}
}
ans = max(ans, score);
}
}
return ans;
}
long long rand(long long a, long long b) { return a + rand() % (b - a + 1); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
cout << solve(n, k, s) << "\n";
}
return 0;
}
| 8 | CPP |
import itertools
import math
import sys
from collections import defaultdict
def stdinWrapper():
data = '''9
5 2
WLWLL
6 5
LLLWWL
7 1
LWLWLWL
15 5
WWWLLLWWWLLLWWW
40 7
LLWLWLWWWLWLLWLWWWLWLLWLLWLLLLWLLWWWLWWL
1 0
L
1 1
L
6 1
WLLWLW
5 2
LWLWL
'''
for line in data.split('\n'):
yield line
if '--debug' not in sys.argv:
def stdinWrapper():
while True:
yield sys.stdin.readline()
inputs = stdinWrapper()
def inputWrapper():
return next(inputs)
def getType(_type):
return _type(inputWrapper())
def getArray(_type):
return [_type(x) for x in inputWrapper().split()]
def tuplerize(method):
def wrap(*args, **kwargs):
res = method(*args, **kwargs)
if not isinstance(res, (tuple, list)):
res = (res, )
return res
return wrap
''' Solution '''
@tuplerize
def solve(k, games):
wins = 0
loses = 0
win_streaks = 0
gaps = []
for i in range(len(games)):
if games[i] == 'W':
wins += 1
if i == 0 or games[i-1] == 'L':
win_streaks += 1
else:
loses += 1
if i == 0 or games[i-1] == 'W':
gaps.append(0)
gaps[-1] += 1
if k >= loses:
return 2 * (len(games)) - 1
if wins == 0:
if k == 0:
return 0
return 2 * k - 1
if games[0] == 'L':
gaps[0] = float('inf')
if games[-1] == 'L':
gaps[-1] = float('inf')
gaps = sorted(gaps)
wins += k
for gap in gaps:
if gap > k:
break
k -= gap
win_streaks -= 1
return 2 * wins - win_streaks
t = getType(int)
for _ in range(t):
n, k = getArray(int)
games = input()
res = solve(k, games)
print(*res)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
s=input()
s=list(s)
cw=0
w=[]
idx=-1
cl=0
fw=-1
lw=-1
ans = 0
for i in range(n):
if(s[i]=='W'):
if(i>0 and s[i-1]=='W'):
ans+=2
else:
ans+=1
if(fw==-1):
fw=i
lw=i
cw+=1
if(idx!=-1):
if(i-idx-1):
w.append(i-idx-1)
idx=i
else:
cl+=1
w.sort()
for i in w:
if(k==0):
break
if(i<=k):
k-=i
ans+=2*(i-1)+3
else:
ans+=2*(k)
k -= k
if(k>0):
if(k>=cl):
ans=1+(n-1)*2
else:
if(cw==0):
if(k>=n):
ans = 1 + (n - 1) * 2
k=0
else:
ans=1+(k-1)*2
k=0
else:
for i in range(lw+1,n):
if(k==0):
break
ans+=2
k-=1
if(k>0):
for i in range(fw-1,-1,-1):
if(k==0):
break
ans+=2
k-=1
print(ans)
| 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
import math
def main():
pass
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")
def binary(n):
return (bin(n).replace("0b", ""))
def decimal(s):
return (int(s, 2))
def pow2(n):
p = 0
while (n > 1):
n //= 2
p += 1
return (p)
def primeFactors(n):
l=[]
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
l.append(i)
n = n / i
if n > 2:
l.append(int(n))
return (l)
def isPrime(n):
if (n == 1):
return (False)
else:
root = int(n ** 0.5)
root += 1
for i in range(2, root):
if (n % i == 0):
return (False)
return (True)
def maxPrimeFactors(n):
maxPrime = -1
while n % 2 == 0:
maxPrime = 2
n >>= 1
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
maxPrime = i
n = n / i
if n > 2:
maxPrime = n
return int(maxPrime)
def countcon(s,i):
c=0
ch=s[i]
for i in range(i,len(s)):
if(s[i]==ch):
c+=1
else:
break
#print("HELLO",i,c)
return(c)
for xyz in range(0,int(input())):
n,k=map(int,input().split())
s=input()
#print(xyz,n,k,s,flush=True)
if(k>=s.count("L")):
print(2*n-1)
elif(s.count("W")==0):
print(max(0,2*k-1))
else:
gaps=[]
streaks=0
i=s.index("W")
#print(i)
while(i<n):
if(s[i]=="W"):
c=countcon(s,i)
streaks+=1
i+=c
else:
c=countcon(s,i)
gaps.append(c)
i+=c
if(s[-1]=="L"):
gaps.pop()
gaps.sort()
#print(s,k)
#print("gaps",gaps)
#print(streaks)
gf=0
ans=2*s.count("W")-streaks
t=k
#print(gaps)
for i in range(0,len(gaps)):
if(gaps[i]>k):
break
else:
gf+=1
k-=gaps[i]
ans+=gf
ans+=t*2
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > gaps;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
gaps.clear();
int n, k, first = -1, ff = -1, l = -1;
string s;
cin >> n >> k >> s;
for (int i = 0; i < s.size(); i++) {
if (ff == -1 && i + 1 < s.size() && s[i] == 'L' && s[i + 1] == 'W')
ff = i + 1;
if (i > 0 && s[i] == 'W' && s[i - 1] == 'L' && first != -1)
gaps.push_back(make_pair(i - first, first));
if (i + 1 < s.size() && s[i] == 'W' && s[i + 1] == 'L') first = i;
if (s[i] == 'W') l = i;
}
sort(gaps.begin(), gaps.end());
for (int i = 0; i < gaps.size(); i++) {
int f = gaps[i].first, second = gaps[i].second;
for (int j = second + 1; j < f + second; j++) {
if (k > 0) {
s[j] = 'W';
k--;
} else
break;
}
if (k == 0) break;
}
if (k > 0) {
for (int i = l + 1; i < s.size(); i++) {
s[i] = 'W';
k--;
if (k == 0) break;
}
if (k > 0) {
for (int i = ff - 1; i >= 0; i--) {
s[i] = 'W';
k--;
if (k == 0) break;
}
}
}
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W') {
ans++;
if (i != 0 && s[i - 1] == 'W') ans++;
}
}
cout << ans << endl;
}
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 winning_streaks_cnt = 0;
int wins = 0;
int losses = 0;
vector<int> losing_streaks;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
wins++;
if (i == 0 or s[i - 1] == 'L') winning_streaks_cnt++;
}
if (s[i] == 'L') {
losses++;
if (i == 0 or s[i - 1] == 'W') losing_streaks.push_back(0);
losing_streaks.back()++;
}
}
if (k >= losses) {
cout << 2 * n - 1 << endl;
continue;
}
if (wins == 0) {
if (2 * k - 1 > 0) {
cout << 2 * k - 1 << endl;
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());
wins += k;
for (int i = 0; i < losing_streaks.size(); i++) {
if (losing_streaks[i] > k) break;
k -= losing_streaks[i];
winning_streaks_cnt--;
}
cout << 2 * wins - winning_streaks_cnt << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100007;
int T, n, k;
char c[N];
int f[N][3], z[N], cnt, cntw, cntz;
int main() {
scanf("%d", &T);
while (T--) {
memset(f, 0, sizeof(f));
memset(z, 0, sizeof(z));
cnt = 0, cntw = 0, cntz = 0;
scanf("%d %d", &n, &k);
cin >> c;
for (int i = 0; i <= n - 1; i++) {
if (c[i] == 'W' && !i) f[++cnt][1] = i;
if (c[i] == 'W' && c[i - 1] == 'L') f[++cnt][1] = i;
if (c[i] == 'W' && c[i + 1] == 'L') f[cnt][2] = i;
if (c[i] == 'W') cntw++;
}
if (!cnt) {
if (k == 0) {
printf("0\n");
continue;
}
if (k <= n) {
printf("%d\n", k * 2 - 1);
continue;
}
if (k > n) {
printf("%d\n", n * 2 - 1);
continue;
}
}
if (cntw + k >= n) {
printf("%d\n", n * 2 - 1);
continue;
}
for (int i = 2; i <= cnt; i++) z[i - 1] = f[i][1] - f[i - 1][2] - 1;
sort(z + 1, z + cnt);
for (int i = 1; i <= cnt - 1; i++) cntz += z[i];
if (k >= cntz) {
printf("%d\n", (cntw + k) * 2 - 1);
continue;
}
int ans = cntw * 2 - cnt;
for (int i = 1; i <= cnt - 1; i++)
if (k >= z[i]) {
k -= z[i];
ans += (z[i] * 2 + 1);
} else {
ans += (k * 2);
break;
}
printf("%d\n", ans);
}
}
| 8 | CPP |
import sys
input=sys.stdin.readline
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
s=input()
streaks=[]
firstwin=-1
for i in range(n):
if s[i]=='W':
firstwin=i
break
if firstwin==-1:
print(max(0,min(2*n-1,2*k-1)))
continue
ans=0
curr=0
for i in range(firstwin,n):
if s[i]=='W':
if i>0 and s[i-1]=='W':
ans+=2
else:
ans+=1
if curr>0:
streaks.append(curr)
curr=0
else:
curr+=1
streaks.sort()
m=len(streaks)
pointer=-1
while pointer+1<m and k>=streaks[pointer+1]:
ans+=streaks[pointer+1]*2+1
k-=streaks[pointer+1]
pointer+=1
ans+=2*k
print(min(ans,2*n-1)) | 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
cntW = s.count('W')
cntL = s.count('L')
cnt = 0
point = 0
gap = []
prevIndex = -1
firstIndex = -1
for i in range(n):
if s[i] == 'W':
cnt += 1
if prevIndex == -1:
prevIndex = i
firstIndex = i
elif i - prevIndex > 1:
gap.append(i - prevIndex - 1)
prevIndex = i
elif cnt > 0:
point += cnt * 2 - 1
cnt = 0
if s[-1] == 'W':
point += cnt * 2 - 1
gap.sort()
j = 0
while j < len(gap) and k > 0:
if gap[j] <= k:
point += 2 * gap[j] + 1
k -= gap[j]
cntL -= gap[j]
j += 1
else:
point += 2 * k
k = 0
if j == len(gap) and k > 0:
point += min(cntL, k) * 2
if cntW == 0:
point = min(cntL, k) * 2 - 1
print(max(point, 0))
| 8 | PYTHON3 |
for test in range(int(input())):
#pocet = int(input())
[n, k] = list(map(int, input().split(" ")))
s = input()
w = False
l = 0
sl = []
pg = False
res = 0
z = 0
ko = 0
for r in s:
if r == "W":
if pg:
res += 2
else:
res += 1
pg = True
if w:
sl.append(l)
l = 0
else:
w = True
else:
if w:
l += 1
pg = False
#print(l)
else:
z += 1
#print("z")
if len(sl)>0:
sl.sort()
c = 0
j = 0
while (j<len(sl)) and (c+sl[j] <= k):
c += sl[j]
if sl[j] >0:
res += sl[j]*2+1
j += 1
if j==len(sl):
res = res + min(k-c, z+l)*2
else:
res = res + (k-c)*2
elif w:
res = res + min((k), z+l)*2
elif k>0:
res = res + min((k), z)*2 - 1
print(res) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long TT;
cin >> TT;
for (long long hhh = 1; hhh <= TT; hhh++) {
long long n, k;
cin >> n >> k;
vector<long long> v;
string s;
cin >> s;
s = "L" + s + "L";
long long ans = 0;
long long add = 0;
long long fw = 0;
for (long long i = 1; i <= n; i++)
if (s[i] == 'W') {
fw = i;
break;
}
for (long long i = 1; i <= n; i++) {
if (s[i] == 'W' && s[i - 1] == 'W') ans += 2;
if (s[i] == 'W' && s[i - 1] != 'W') ans += 1;
if (s[i] == 'W' && i > fw) {
if (add > 0) v.push_back(add);
add = 0;
} else {
add++;
}
if (i == fw) {
add = 0;
}
}
if (v.size() > 0) sort(v.begin(), v.end());
long long first = 0;
long long last = 0;
long long i = 1;
while (i <= n && s[i] != 'W') {
first++;
i++;
}
i = n;
while (i >= 1 && s[i] != 'W') {
last++;
i--;
}
if (v.size() == 0 && first == 0 && last == 0) {
cout << ans << endl;
continue;
}
if (ans == 0) {
if (k > 0)
cout << 2 * k - 1 << endl;
else
cout << 0 << endl;
continue;
}
for (long long i = 0; i < v.size(); i++) {
if (k >= v[i]) {
ans += (v[i] * 2 + 1);
k = k - v[i];
} else {
ans += 2 * k;
k = 0;
}
}
if (k >= last) {
ans += 2 * last;
k = k - last;
} else {
ans += 2 * k;
k = 0;
}
if (k >= first) {
if (k > 0) ans += 2 * first;
k = k - first;
} else {
if (k > 0) ans += 2 * k;
k = 0;
}
cout << ans << endl;
}
}
| 8 | CPP |
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import sys
import time
import string
sys.setrecursionlimit(99999)
for _ in range(int(input())):
n,k = map(int,input().split())
s = input().strip("L")
cw = s.count("W")+k
t = []
for key,value in itertools.groupby(s):
if key=="L":
t.append(len(list(value)))
t.sort()
while t and t[0]<=k:
k-=t.pop(0)
print(max(0,2*min(n,cw)-len(t)-1)) | 8 | PYTHON3 |
def count(s):
wins = 0
l = 0
arr = []
prev = None
for e in s:
if e == "L":
if prev == "W" or l > 0:
l += 1
if e == "W":
wins += 1
if l > 0:
arr.append(l)
l = 0
prev = e
return wins, arr
t = int(input())
# t = 1
for _ in range(t):
# n, k = 5, 2
# s = "WLWLL"
# n = len(s)
n, k = [int(i) for i in input().split()]
s = [c for c in input()]
wins, arr = count(s)
streaks = len(arr)+1
if wins == 0:
print(max(2*min(n, k)-1, 0))
elif wins + k >= n:
print(2*n-1)
else:
kt = k
arr.sort(reverse=True)
while kt > 0 and len(arr) > 0:
kt -= arr.pop()
if kt >= 0:
streaks -= 1
print(2*(k+wins)-streaks) | 8 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.