solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
t = int(input())
ans = []
for test in range(t):
n, k = [int(i) for i in input().split()]
a = input()
loses = sum([1 for i in a if i == 'L'])
if 'W' not in a:
ans.append(max(0, k * 2 - 1))
elif loses <= k:
ans.append(len(a) * 2 - 1)
else:
losing = False
left = a.find('W')
segs = []
cost = 0
for i in range(left, n):
if losing is True and a[i] == 'W':
segs.append(i - left)
left = i
losing = False
elif losing is False and a[i] == 'L':
cost += (i - left) * 2 - 1
left = i
losing = True
if a[-1] == 'W':
cost += (n - left) * 2 - 1
total = sum(segs)
if k > total:
ans.append(cost + 2 * total + len(segs) + (k - total) * 2)
else:
segs.sort()
cs = 0
left = 0
for i, seg in enumerate(segs):
if k >= cs + seg:
cs += seg
left = i + 1
else:
break
ans.append(cost + 2 * cs + left + (k - cs) * 2)
print(*ans, sep='\n')
| 8 | PYTHON3 |
import sys, os
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))
# read_f = lambda file: list(map(int, file.readline().strip().split()))
MOD = 998244353
# def f(arr, i, s, res):
# if i == len(arr):return(res)
# f(arr)
def main():
ans = []
for _ in range(int(input())):
n, k = read(); t = input().strip()
s = "Z"+t+"Z"
s = s.split("W")
s.sort()
score = 0
for i in range(n):
if t[i] == "W":
if i > 0 and t[i-1] == "W":score += 2
else:score += 1
if k == 0:ans.append(str(score));continue
# print(score)
for i in s:
if not i:continue
if i == "Z":continue
if i[0] == "Z" and i[-1] == "Z":
score += 2*(min(k, len(i)-2)) - 1
k -= min(k, len(i)-2)
# print(i, "1*********")
elif not (i[0] == "Z" or i[-1] == "Z"):
score += 2*(min(k, len(i)))+[0, 1][k >= len(i)]
k -= min(k, len(i))
# print(i, "2*********")
else:
score += 2*(min(k, len(i)-1))
k -= min(k, len(i)-1)
# print(i, "3*********")
if k == 0:
break
ans.append(str(score))
print("\n".join(ans))
if __name__ == "__main__":
main()
| 8 | PYTHON3 |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
from bisect import bisect_right
from math import gcd,log
from collections import Counter
from pprint import pprint
def main():
# n=int(input())
n,m=map(int,input().split())
# arr=list(map(int,input().split()))
s=[c for c in input()]
start=0
end=0
a=[]
wc=s.count('W')
while end<n and start<n:
if s[start]=='L':
end=start
while end<n and s[end]=='L':
end+=1
if start!=0 and end!=n:
a.append((end-start,start) )
start=end-1
start+=1
a.sort(reverse=True)
# print(a)
while m and len(a):
l,st=a.pop()
# print(m,a)
for i in range(st,st+l):
m-=1
# print(s)
s[i]='W'
if not m:
break
ind=0
while ind<n and s[ind]=='L':
ind+=1
j=ind-1
while j>=0 and m:
s[j]='W'
j-=1
m-=1
end=n-1
while end>=0 and s[end]=='L':
# print(s[end],end)
end-=1
j=end+1
# print('M',m,j)
while j<n and m:
s[j]='W'
j+=1
m-=1
# print(s)
ans=0
if s[0]=='W':
ans+=1
for i in range(1,n):
if s[i]=='W':
if s[i-1]== 'W':
ans+=1
ans+=1
print(ans)
# print(a)
# print(ans)
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__":
for _ in range(int(input())):
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx")
using namespace std;
template <class T>
T make_vec(T default_value) {
return default_value;
}
template <class T, class Arg, class... Args>
auto make_vec(T default_value, Arg size, Args... rest)
-> vector<decltype(make_vec(default_value, rest...))> {
auto level = make_vec(default_value, rest...);
return vector<decltype(level)>(size, level);
}
template <class Xs>
int sz(const Xs &xs) {
return static_cast<int>(xs.size());
}
using i64 = int64_t;
using f80 = long double;
using Str = string;
template <class T = int>
using Vec = vector<T>;
template <class K = int, class H = hash<K>>
using US = unordered_set<K, H>;
template <class K, class V, class H = hash<K>>
using UM = unordered_map<K, V, H>;
template <class U = int, class V = U>
using P = pair<U, V>;
using G = Vec<Vec<int>>;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
Str s;
cin >> s;
if (all_of(s.begin(), s.end(), [](char c) { return c == 'W'; })) {
cout << 2 * n - 1 << '\n';
continue;
}
if (all_of(s.begin(), s.end(), [](char c) { return c == 'L'; })) {
cout << max(0, 2 * min(n, k) - 1) << '\n';
continue;
}
Vec<int> blocks{0};
for (auto c : s) {
if (c == 'W') {
if (blocks.back() > 0) blocks.push_back(0);
} else {
blocks.back() += 1;
}
}
if (blocks.back() == 0) blocks.pop_back();
if (s.front() == 'L') blocks.front() |= 1 << 20;
if (s.back() == 'L') blocks.back() |= 1 << 20;
int score = 0;
for (int i = 0; i < n; ++i) score += s[i] == 'W';
for (int i = 0; i + 1 < n; ++i) score += s[i] == 'W' && s[i + 1] == 'W';
sort(blocks.begin(), blocks.end());
for (auto block : blocks) {
int size = block & ~(1 << 20);
bool flag = block >> 20;
if (k < size) {
score += 2 * k;
break;
}
score += 2 * size + 1 - flag;
k -= size;
}
cout << score << '\n';
}
}
namespace {
auto fast_io = [] {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(8) << fixed;
cerr << boolalpha << setprecision(4) << fixed;
return 0;
}();
}
| 8 | CPP |
def solve():
n,k=map(int,input().split())
K=k
s=list(input())
if s.count('W')+k>n:
print(2*n-1)
return
if s.count('W')==0:
print(min(k,n)*2-1 if k!=0 else 0)
return
arr=[]
streak=0
i=0
while i<n:
j=i
while(j<n and s[j]==s[i]):
j+=1
if s[i]=='W':
streak+=1
else:
if 0<i and j<n:
arr.append(j-i)
i=j
arr.sort()
for c in arr:
if c>k:
break
streak-=1
k-=c
print(2*(K+s.count('W'))-streak)
return
t=int(input())
for _ in range(t):
solve() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void test() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> gaps;
int gap = 0;
char prev = s[0];
bool w = false;
int ans = 0;
int start = 0;
if (prev == 'W') {
w = true;
ans++;
start = 0;
} else
start++;
for (int i = 1; i < n; i++) {
char cur = s[i];
if (!w) {
if (cur == 'W') {
w = true;
} else
start++;
} else {
if (cur == 'W') {
if (gap != 0) gaps.push_back(gap);
gap = 0;
} else {
gap++;
}
}
if (cur == 'W') {
if (prev == cur)
ans += 2;
else
ans++;
}
prev = cur;
}
if (w == false) {
if (k == 0) {
cout << 0 << endl;
return;
}
int res = 2 * min(k, n) - 1;
cout << res << endl;
return;
}
int end = gap;
sort(gaps.begin(), gaps.end());
for (int i = 0; i < gaps.size(); i++) {
int g = gaps[i];
if (g <= k) {
k -= g;
ans += 2 * g + 1;
} else {
ans += 2 * k;
k = 0;
break;
}
}
if (k > 0) {
int ori = k;
k -= end;
k = max(0, k);
ans += 2 * (ori - k);
if (k > 0) ans += 2 * min(start, k);
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
test();
}
}
| 8 | CPP |
nums = int(input().strip())
for _ in range(nums):
n,k = map(int,input().strip().split())
s = input().strip()
cur_score = 0
l_part = []
cur_num=0
l_count =w_count= 0
for i,v in enumerate(s):
if v=="W":
w_count+=1
if i>0 and s[i-1]=="W":
cur_score+=2
continue
elif i>0 and s[i-1]=="L":
l_part.append(cur_num)
cur_num=0
cur_score+=1
else:
cur_num+=1
l_count+=1
if cur_num:
l_part.append(cur_num)
if k>=l_count:
print(2*len(s)-1)
else:
if l_part:
start,end = 0,len(l_part)
if s[0]=="L":
start+=1
if s[-1]=="L":
end-=1
arr = sorted(l_part[start:end])
for i in range(len(arr)):
if k>=arr[i]:
cur_score+=2*arr[i]+1
k-=arr[i]
else:
break
res = cur_score+k*2
if w_count==0:
res-=1
print(max(res,0))
else:
print(cur_score) | 8 | PYTHON3 |
t = int(input())
for tt in range(t):
n, k = map(int, input().split())
s = input()
pre = False
cur = 0
mid = []
for i, c in enumerate(s):
if c == 'W':
if pre:
if cur:
mid.append(cur)
else:
begin = cur
pre = True
cur = 0
else:
cur += 1
end = cur
# print(mid, begin, end)
if end == n:
ans = k * 2 - 1 if k else 0
else:
mid.sort()
ans = 0
for m in mid:
if not k:
break
if k < m:
ans += 2 * k
k = 0
else:
ans += 2 * m + 1
k -= m
# print('remain k:', k)
end = min(end, k)
ans += end * 2
k -= end
begin = min(begin, k)
ans += begin * 2
k -= begin
pre = False
# print('added: ', ans)
for i, c in enumerate(s):
if c == 'W':
ans += 2 if pre else 1
pre = True
else:
pre = False
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int dx1[4] = {-1, 0, 1, 0};
int dy1[4] = {0, 1, 0, -1};
int intialAnswer(string s) {
int ans = 0, n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
ans++;
i++;
while (i < n && s[i] == 'W') i++, ans += 2;
}
}
return ans;
}
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (n == 1) {
if (s[0] == 'W' || k > 0)
cout << "1";
else
cout << "0";
return;
}
int lastW = s.find_last_of('W');
int firstW = s.find_first_of('W');
int startRemaining, lastRemaining;
if (lastW == -1) {
int mn = min(n, k);
int ans = 0;
if (mn > 0) {
ans = 1 + 2 * (mn - 1);
}
cout << ans;
return;
} else {
startRemaining = firstW;
lastRemaining = n - 1 - lastW;
}
vector<int> lengths;
for (int i = firstW + 1; i <= lastW; i++) {
int l = 0;
while (i < lastW && s[i] == 'L') i++, l++;
if (l != 0) lengths.push_back(l);
}
sort(lengths.begin(), lengths.end());
int ans = intialAnswer(s);
for (int x : lengths) {
if (x <= k) {
ans = ans + 2 * x + 1;
k -= x;
} else {
ans = ans + 2 * k;
k = 0;
}
if (k == 0) break;
}
if (k > 0) {
ans = ans + 2 * min(lastRemaining, k);
k -= min(lastRemaining, k);
if (k > 0) {
ans = ans + 2 * (min(startRemaining, k));
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 8 | CPP |
def countStr(string, str_len):
l_len, l_sum = 0, 0
sw_idx, ew_idx = -1, -1
l_count = {}
l_flag, sw_flag = False, False
for i in range(str_len):
s = string[i]
if (sw_flag and s == 'L'):
l_flag = True
l_len += 1
elif (s == 'W'):
if l_flag:
l_sum += l_len
l_count[l_len] = l_count.get(l_len, 0) + 1
l_len = 0
l_flag = False
if not sw_flag:
sw_flag = True
sw_idx = i
ew_idx = i
return l_sum, l_count, sw_idx, ew_idx
def reslove(wl_str, n, k):
l_sum, l_count, sw_idx, ew_idx = countStr(wl_str, n)
L_left_len = sw_idx
L_right_len = n - ew_idx - 1
L_all_len = L_left_len + l_sum + L_right_len
if sw_idx < 0:
if k == 0 or n == 0:
return 0
w = k if n > k else n
return 2 * w - 1
if L_all_len <= k:
return 2 * n - 1
if l_sum < k:
w = n - L_all_len + k
return 2 * w - 1
lens = list(l_count.keys())
lens.sort()
w = n - L_all_len
bp = sum(l_count.values()) + 1
for len in lens:
len_ct = l_count[len]
l_ct = len * len_ct
if l_ct <= k:
bp -= len_ct
w += l_ct
k -= l_ct
else:
filled = k // len
bp -= filled
w += k
break
return w * 2 - bp
t = int(input())
for i in range(t):
n, k = map(int, input().split())
wl_str = input()
print(reslove(wl_str, n, k))
| 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
import math
from itertools import permutations
from decimal import *
getcontext().prec = 25
MOD = pow(10, 9) + 7
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")
# n, k = map(int, input().split(" "))
# l = list(map(int, input().split(" ")))
for _ in range(int(input())):
n, k = map(int, input().split(" "))
l = input()
if n == k:
print(2 * k - 1)
else:
t = 0
z = []
w = L = False
le = pre = 0
for i in range(n):
if l[i] == "L":
L = True
pre += 1
else:
break
start = max(1, pre)
if l[0]=="W":
t+=1
for i in range(start, n):
if l[i] == "W":
w=True
if le:
z.append(le)
le = 0
if l[i - 1] == "W":
t += 2
else:
t += 1
if l[i] == "L":
L = True
le += 1
extra = le
z.sort()
if k == 0 or not L:
print(t)
elif not extra and not z:
if not w:
print(2*(min(pre,k)) -1)
else:
print(2*(min(pre,k))+t)
elif not z:
t += 2 * (min(pre, k))
k = max(0, k - pre)
t += 2 * (min(k, extra))
print(t)
elif z:
for i in range(len(z)):
if z[i] <= k:
k -= z[i]
t += 2 * z[i] + 1
else:
t += 2 * k
k = 0
break
if k:
t += 2 * (min(pre, k))
k = max(0, k - pre)
t += 2 * (min(k, extra))
print(t)
| 8 | PYTHON3 |
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.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(io.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()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
from itertools import groupby
T = int(input())
for _ in range(T):
N, K = map(int, input().split())
S = input()
L_lens = []
ans = 0
for wl, gr in groupby(S):
n = len(list(gr))
if wl == "L":
L_lens.append(n)
else:
ans += n*2-1
l_cnt = sum(L_lens)
if l_cnt == N:
ans = K * 2 - 1
if K == 0:
ans = 0
print(ans)
continue
k = min(K, l_cnt)
if S[0] == "L":
del L_lens[0]
if S[-1] == "L":
del L_lens[-1]
L_lens.sort()
ans += k * 2
for l_len in L_lens:
if k >= l_len:
ans += 1
k -= l_len
print(ans)
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
score = 0
tmp = s.count('L')
for i in range(1, n):
if s[i] == "W" and s[i - 1] == "W":
score += 2
elif s[i] == "W":
score += 1
if s[0] == 'W':
score += 1
if k == 0:
print(score)
continue
res = []
idx = s.find('W')
count = 0
for i in range(idx + 1, n):
if s[i] == 'L':
count += 1
elif (s[i]=="W" and count!=0) or (i==n-1 and s[i]=="L"):
res.append(count)
count = 0
res.sort()
i = 0
while k > 0 and i < len(res):
if res[i] <= k:
k -= res[i]
score += 2 * res[i]
score += 1
else:
score += 2 * k
k = 0
i += 1
if 'W' in s:
score += 2 * min(k, (tmp - sum(res)))
else:
if k<=n:
score += 2 * k - 1
else:
score += 2 * n - 1
print(score) | 8 | PYTHON3 |
def testcase():
n, k = map(int, input().split())
s = list(input())
ans = 0
if s[0] == 'W':
ans += 1
for i in range(1, n):
if s[i] == 'W':
ans += 1
if s[i - 1] == 'W':
ans += 1
fw = 0
while fw < n and s[fw] == 'L':
fw += 1
lw = n - 1
while lw >= 0 and s[lw] == 'L':
lw -= 1
gaps = []
gap = 0
for i in range(fw, lw + 1):
if s[i] == 'L':
gap += 1
else:
if gap != 0:
gaps.append(gap)
gap = 0
gaps.sort()
for gap in gaps:
if k >= gap:
ans += 2 * gap + 1
k -= gap
else:
ans += 2 * k
k = 0
break
if k > 0 and lw != -1:
tl = n - lw - 1
ans += 2 * min(k, tl)
k = max(0, k - tl)
if k > 0:
sl = fw
ans += 2 * min(k, sl)
if fw == n:
if k == 0:
ans = 0
else:
ans = 2 * k - 1
print(ans)
return
t = int(input())
for _ in range(t):
testcase() | 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n,k = list(map(int, input().split()))
string = list(input())
# eliminate boarder
lis = []
i = 0
j = n-1
counter = 0
for _i_ in string:
if _i_ != 'W':
counter+=1
i+=1
else:
break
b1 = (counter , 0)
#print(b1)
counter = 0
for _i_ in reversed(string):
if _i_ != 'W':
counter+=1
j-=1
else:
break
b2 = (counter , j+1)
while i <= j:
counter = 0
if string[i] == 'L':
q = i
while string[i] == 'L':
counter+=1
i+=1
lis.append((counter , q))
else:
i+=1
lis.sort()
#lis.append(b1)
#lis.append(b2)
#print(lis)
for i in lis:
if k<=0:
break
count = i[0]
j = i[1]
for i in range(j , j+count):
string[i] = 'W'
k-=1
if k <= 0:
break
c, index = b1
for i in range(index + c - 1, index - 1, -1):
if k == 0:
break
else:
string[i] = 'W'
k-=1
c,index = b2
for i in range(index, index + c):
if k == 0:
break
else:
string[i] = 'W'
k -= 1
prev = 'L'
count = 0
for i in string:
if i == 'W' and prev == 'W':
count+=2
elif i == 'W':
count+=1
prev = i
print( count) | 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
tmp = k
s = input()
k = max(0, n - s.count('W') - k)
l = [0]
for i in range(n):
if i > 0 and s[i - 1] == s[i] == 'W':
continue
if s[i] == 'W':
l.append(0)
else:
l[-1] += 1
if len(l) == 1:
if s[0] == 'W':
print(2 * n - 1)
else:
print(max(0, 2 * tmp - 1))
continue
p = l[0]
q = l[-1]
l = sorted(l[1:-1], reverse=True)
m = len(l)
s = 0
ans1, ans2, ans3, ans4 = 1000000000, 100000000000, 1000000000000, 1000000000000
for i in range(len(l)):
if s >= k:
ans1 = k * 2 + i
break
s += l[i]
else:
if s >= k:
ans1 = k * 2 + m
s = 0
for i in range(len(l)):
if s + p >= k:
ans2 = k * 2 + i
break
s += l[i]
else:
if s + p >= k:
ans2 = k * 2 + m
s = 0
for i in range(len(l)):
if s + q >= k:
ans3 = k * 2 + i
break
s += l[i]
else:
if s + q >= k:
ans3 = k * 2 + m
s = 0
for i in range(len(l)):
if s + p + q >= k:
ans4 = k * 2 + i
break
s += l[i]
else:
if s + p + q >= k:
ans4 = k * 2 + m
print(n * 2 - 1 - min(ans1, ans2, ans3, ans4))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000 + 10;
const long long INF = 1LL * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 10;
long long arr[MAXN];
vector<long long> l;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
l.clear();
bool mark = false;
long long first = 0, last = 0, pos = 0, ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
ans++;
if (s[i - 1] == 'W') ans++;
if (mark) {
if (pos != 0) {
l.push_back(pos);
pos = 0;
}
} else {
first = pos;
pos = 0;
mark = true;
}
} else
pos++;
}
last = pos;
if (!mark) {
cout << max(0LL, min(n, k) * 2 - 1) << endl;
continue;
}
sort(l.begin(), l.end());
int ind = 0;
while (k != 0 and ind != l.size()) {
if (l[ind] > k) {
ans += k * 2;
k = 0;
} else {
ans += l[ind] * 2 + 1;
k -= l[ind];
}
ind++;
}
if (k > 0) {
ans += min(k, last) * 2;
k -= last;
if (k > 0) ans += min(k, first) * 2;
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
# cook your dish here
t=int(input())
for x in range(t):
n,k=input().split(' ')
n=int(n)
k=int(k)
s=input()
count_=s.count('W')
calculate=0
prev=0
li=[]
pre=-1
for x in range(n):
if s[x]=='W':
if pre==-1:
pre=x
calculate=1
else:
li.append(x-pre-1)
if x-pre==1:
calculate+=2
else:
calculate+=1
pre=x
li.sort()
#print(li)
#print(calculate)
for x in li:
if x!=0:
if k>=x:
calculate+=2*x+1
k=k-x
count_+=x
#print(calculate)
elif k<x:
calculate+=2*k
count_+=k
#print(calculate)
k=0
break
#print('k',k)
#print('count',count_)
if calculate==0 and k>0:
calculate=-1
if k!=0:
if n-count_>=k:
calculate+=2*k
count_+=k
elif n-count_<k:
calculate+=2*(n-count_)
count_+=n-count_
print(calculate)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v;
int cnt = 0, ans = 0, hoge = 0;
while (s[hoge] == 'L' && hoge < n) hoge++;
if (hoge == n) {
cout << max(2 * min(n, k) - 1, 0) << endl;
return;
}
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
if (i > hoge && cnt > 0) v.push_back(cnt);
cnt = 0;
ans++;
if (i && s[i - 1] == 'W') ans++;
} else
cnt++;
}
sort((v).begin(), (v).end());
for (int i = 0; i < v.size(); i++) {
if (!k) break;
if (v[i] <= k) {
k -= v[i];
ans += 2 * v[i] + 1;
} else {
ans += k * 2;
k = 0;
}
}
int tmp = min(hoge, k);
k -= tmp;
ans += tmp * 2;
tmp = min(cnt, k);
ans += tmp * 2;
cout << ans << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 8 | CPP |
# coding=utf-8
# Created by TheMisfits
from sys import stdin
_input = stdin.readline
_range, _dict, _int, _sorted, _list, _str = range, dict, int, sorted, list, str
from collections import defaultdict
def solution():
for _ in _range(_int(_input())):
n, k = [_int(i) for i in _input().split()]
arr = _list(_input().rstrip('\n'))
d = defaultdict(_int)
current_win = -1
ans = 0
l_lose = 0
for i in _range(n):
if current_win == -1 and arr[i] == 'L':
l_lose += 1
if arr[i] == 'W' and current_win < 0:
current_win = i
elif arr[i] == 'W' and i - current_win > 1:
d[i-current_win-1]+= 1
current_win = i
elif arr[i] == 'W':
current_win = i
if i == 0:
if arr[i] == 'W':
ans += 1
else:
if arr[i-1] == 'W' and arr[i] == 'W':
ans += 2
elif arr[i] == 'W':
ans += 1
if current_win == -1:
if k > 0:
if k >= l_lose:
ans += (l_lose - 1) * 2 + 1
else:
ans += (k - 1) * 2 + 1
print(ans)
continue
r_lose = 0
for i in _range(n-1, -1, -1):
if arr[i] == 'L':
r_lose += 1
else:
break
for i in _sorted(d.keys()):
if k >= d[i]*i:
ans += d[i]*(i*2+1)
k -= d[i]*i
else:
ans += (k//i)*(i*2+1)
ans += (k%i)*2
k = 0
break
if k > 0:
if k >= l_lose:
ans += l_lose*2
k -= l_lose
else:
ans += k*2
k = 0
if k > 0:
if k >= r_lose:
ans += r_lose*2
k -= r_lose
else:
ans += k*2
k = 0
print(ans)
solution() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 100;
const unsigned long long LINF = 1e18 + 100;
const int ITER = 300;
const double EPS = 1e-6;
const unsigned long long MOD = 1e9 + 7;
const unsigned long long MAXN = 1e6 + 100;
int a[MAXN];
int n;
int count_ans(string& s) {
int ans = (s[0] == 'W');
for (int i = 1; i < n; ++i) {
if (s[i] == 'W') {
if (s[i - 1] == 'W')
ans += 2;
else
++ans;
}
}
return ans;
}
bool cmp(pair<int, int> lhs, pair<int, int> rhs) {
return (lhs.second - lhs.first) < (rhs.second - rhs.first);
}
void solve() {
int k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<int, int>> segs;
int l = find(s.begin(), s.end(), 'W') - s.begin();
int r = n - 1 - (find(s.rbegin(), s.rend(), 'W') - s.rbegin());
for (int i = l; i <= r; ++i) {
if (s[i] == 'W') continue;
int rr = i;
while (rr < r && s[rr] == 'L') ++rr;
segs.push_back({i, rr});
i = rr - 1;
}
sort(segs.begin(), segs.end(), cmp);
for (int i = 0; i < (int)segs.size() && k; ++i) {
for (int j = segs[i].first; j < segs[i].second && k; ++j) {
s[j] = 'W';
--k;
}
}
while (++r < n && s[r] == 'L' && k) {
--k;
s[r] = 'W';
}
while (--l >= 0 && s[l] == 'L' && k) {
--k;
s[l] = 'W';
}
cout << count_ans(s);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (int cs = 0; cs < t; ++cs) {
solve();
cout << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<long long, long long>;
const long long INF = 2e18;
template <class A, class B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class A>
ostream &operator<<(ostream &os, const vector<A> &v) {
os << "{";
for (long long i = 0; i < (long long)v.size(); i++)
if (i == 0)
os << v[i];
else
os << ", " << v[i];
os << "}";
return os;
}
void dprint(string s) { cout << "\n"; }
template <class T, class... U>
void dprint(string s, T t, U... u) {
long long w = s.find(',');
cout << "[" << s.substr(0, w) << ": " << t << "] ";
dprint(s.substr(w + 2, (long long)s.size() - w - 1), u...);
}
const long long N = 1e6 + 5;
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long sc = 0;
vector<long long> v;
if (s[0] == 'W') v.push_back(0);
for (long long i = 0; i < n;) {
char c = s[i];
long long cnt = 0;
while (s[i] == c and i < n) i++, cnt++;
if (c == 'W')
sc += 2 * (cnt - 1) + 1;
else
v.push_back(cnt);
}
if (s[n - 1] == 'W') v.push_back(0);
if (k == 0) {
cout << sc << "\n";
return;
}
if ((long long)(v).size() == 1) {
if (s[0] == s[n - 1]) {
long long take = min(v[0], k);
sc += 2 * (take - 1) + 1;
cout << sc << "\n";
return;
}
}
long long st = 0, end = 0;
st = v[0] + v[(long long)(v).size() - 1];
vector<long long> d;
for (long long i = 1; i < (long long)(v).size() - 1; i++) d.push_back(v[i]);
v = d;
sort((v).begin(), (v).end());
for (long long x : v) {
long long take = min(x, k);
k -= take, x -= take;
if (x == 0)
sc += 2 * (take) + 1;
else {
sc += 2 * take;
break;
}
}
long long take = min(st, k);
st -= take, k -= take;
sc += 2 * take;
cout << sc << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
for (long long tc = 1; tc <= T; tc++) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long N = 1e3 + 10;
const long long IM = 1e18 + 37;
inline void PP(long long n) { cout << n << " "; }
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PVV(vector<pair<long long, long long> > v) {
for (long long i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << "\n";
}
void PA(long long v[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cout << v[i] << ' ';
cout << "\n";
}
void IN(long long a[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cin >> a[i];
}
inline void op() {}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
op();
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> v;
bool f = 0;
long long x = 0, ans = 0;
vector<long long> b;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
if (f) {
if (x) v.push_back(x);
x = 0;
} else {
b.push_back(x);
x = 0;
}
f = 1;
if (i && s[i - 1] == 'W')
ans += 2;
else if (s[i] == 'W')
ans++;
} else
x++;
}
if (x) {
b.push_back(x);
}
sort(v.begin(), v.end());
for (auto it : v) {
long long x = it;
if (it <= k) {
ans += it + it + 1;
k = k - it;
} else {
ans += k + k;
k = 0;
}
if (k == 0) break;
}
if (k != 0 && b.size()) {
if (f == 0) {
long long x = min(n, k);
ans += x + x - 1;
} else {
for (auto it : b) {
long long x = min(it, k);
ans += x + x;
k = k - x;
}
}
}
cout << (ans) << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
for (auto& v : vec) is >> v;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[ ";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1) os << ", ";
}
os << " ]\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[ ";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << " ]\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[ ";
for (auto it : v) os << it << ", ";
os << " ]\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
os << "{ ";
for (auto it : v) os << it.first << " : " << it.second << ", ";
os << " }\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << ", " << v.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, priority_queue<T> p) {
os << "[ ";
while (!p.empty()) {
os << p.top() << " ,";
p.pop();
}
os << " ]\n";
return os;
}
inline long long pmod(long long i, long long n) { return (i % n + n) % n; }
const long long INF = 1e18;
const long long mod = 1e9 + 7;
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long fw = -1, lw = -2;
for (long long(i) = (0); (i) <= (n - 1); ++(i))
if (s[i] == 'W') {
fw = i;
break;
}
for (long long(i) = (n - 1); (i) >= (0); --(i))
if (s[i] == 'W') {
lw = i;
break;
}
vector<pair<long long, long long>> cnt;
long long cur = 0, pos;
for (long long(i) = (fw); (i) <= (lw); ++(i)) {
if (s[i] == 'W') continue;
if (!cur) pos = i;
++cur;
if (i + 1 <= lw && s[i + 1] == 'L') continue;
cnt.push_back({cur, pos});
cur = 0;
}
sort((cnt).begin(), (cnt).end());
for (auto&(e) : (cnt))
for (long long(i) = (e.second); (i) <= (e.first + e.second - 1); ++(i))
if (k) {
--k;
s[i] = 'W';
}
if (fw != -1)
for (long long(i) = (fw - 1); (i) >= (0); --(i))
if (k) {
s[i] = 'W';
--k;
}
if (lw != -2)
for (long long(i) = (lw + 1); (i) <= (n - 1); ++(i))
if (k) {
s[i] = 'W';
--k;
}
for (long long(i) = (0); (i) <= (n - 1); ++(i))
if (s[i] == 'L' && k) {
s[i] = 'W';
--k;
}
long long ans = (s[0] == 'W');
for (long long(i) = (1); (i) <= (n - 1); ++(i))
if (s[i] == 'W')
if (s[i - 1] == 'W')
ans += 2;
else
++ans;
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
for (int t1 = 1; t1 <= t; ++t1) {
solve();
cout << '\n';
}
}
| 8 | CPP |
t = int(input())
for _ in range(t):
n, k = input().split()
n, k = int(n), int(k)
s = input()
ind = []
if ('W' not in s):
print(max(0, min(2*n-1, 2*k-1)))
continue
score = 0
prev = 'L'
ind = []
for i in range(len(s)):
if (s[i] == 'W') and (prev == 'W'):
score += 2
ind.append(i)
elif s[i] == 'W':
score += 1
ind.append(i)
prev = s[i]
gaps = []
for i in range(len(ind)-1):
if ind[i+1] - ind[i] > 1:
gaps.append(ind[i+1] - ind[i])
gaps = sorted(gaps)
## print(score)
## print(gaps)
j = 0
while (j < len(gaps)) and (k >= gaps[j] - 1):
k -= gaps[j] - 1
score += 2*gaps[j] - 1
j += 1
## print('k: ', k, 'score:', score)
print(min(2*n-1, score + 2*k))
| 8 | PYTHON3 |
import sys
input=sys.stdin.readline
t=int(input())
for i in range(t):
n,k=map(int,input().split())
state=input()
state=[i for i in state]
ans,prev=0,0
store=[]
if state[0]=='W':
rang=[-1]
else:
rang=[]
for i in range(len(state)):
if state[i]=='W':
if len(rang)==1:
if rang[0]==i-1:
rang=[i]
else:
store.append((i-rang[0]-1,rang[0]+1,i))
rang=[i]
else:
rang=[i]
last=(rang[0] if rang else 0)
store.sort()
if k>0:
for i in store:
for j in range(i[1],i[2]):
state[j]='W'
k-=1
if k==0:
break
if k==0:
break
if k>0:
for i in range(last+1,len(state)):
if state[i]=='L' :
state[i]='W'
k-=1
if k==0:
break
if k>0:
for i in range(len(state)-1,-1,-1):
if state[i]=='L' :
state[i]='W'
k-=1
if k==0:
break
if state[0]=='W':
ans=1
else:
ans=0
for i in range(1,len(state)):
if state[i]=='W':
if state[i-1]=='W':
ans+=2
else:
ans+=1
sys.stdout.write(str(ans)+'\n')
| 8 | PYTHON3 |
from sys import *
from math import *
from bisect import *
t=int(stdin.readline())
for _ in range(t):
n,k=map(int,stdin.readline().split())
s=input()
c=[]
f=0
w=0
l=0
for i in range(n):
if s[i]=="W":
w+=1
else:
l+=1
for i in range(n):
if s[i]=="W" and f==0:
f=1
j=i
elif f==1 and s[i]=="W":
c.append(i-j-1)
j=i
d=[]
for i in range(len(c)):
if c[i]!=0:
d.append(c[i])
ans=0
d.sort()
for i in range(len(d)):
if d[i]<=k:
k-=d[i]
ans+=2*(d[i]-1)+3
l-=d[i]
else:
break
for i in range(n):
if s[i]=="W":
if i==0:
ans+=1
elif s[i-1]=="L":
ans+=1
else:
ans+=2
ans+=min(k,l)*2
if w==0 and k>0:
ans-=1
print(ans)
| 8 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
a=input()
if(k==0):
c=a.split('L')
ans=0
for i in range(len(c)):
if(len(c[i])>=1):
ans=ans+((len(c[i])-1)*2+1)
print(ans)
continue
c=a.split('W')
counter={}
for i in range(1,len(c)-1):
if(len(c[i])>0):
zz=len(c[i])
if(zz in counter):
counter[zz]+=1
else:
counter[zz]=1
ans=0
counter1=[]
#print(counter)
for i in counter:
counter1.append([i,counter[i]])
#print(counter1)
if(len(c)==1):
print(max((min(len(c[0]),k)-1)*2+1,0))
continue
counter=counter1
counter.sort()
#print(counter)
for i in range(len(counter)):
if(counter[i][0]*counter[i][1]<=k):
k-=counter[i][1]*counter[i][0]
ans+=((counter[i][0]-1)*2+3)*counter[i][1]
else:
ans1=k//counter[i][0]
ans+=((counter[i][0]-1)*2+3)*ans1
ans1=k%counter[i][0]
k=0
ans+=ans1*2
break
#print(ans)
ramu=c[0].count('L')+c[-1].count('L')
h=min(ramu,k)
ans+=h*2
c=a.split('L')
for i in range(len(c)):
if(len(c[i])>=1):
ans=ans+((len(c[i])-1)*2+1)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
string s;
void solve(long long n, long long k, string s) {
vector<long long> v;
long long win = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
win++;
}
}
if (win == 0 and k != 0) {
cout << (2 * k) - 1 << endl;
return;
} else if (win == 0 and k == 0) {
cout << 0 << endl;
return;
}
win += k;
if (win >= n) {
cout << (2 * n) - 1 << endl;
return;
}
long long l = 0;
long long j = 0;
while (j < n) {
if (s[j] == 'L') {
l++;
} else {
v.push_back(l);
l = 0;
}
j++;
}
if (l != 0) {
v.push_back(l);
}
if (s[0] == 'L') {
v.erase(v.begin());
}
if (s[n - 1] == 'L') {
v.erase(v.begin() + v.size() - 1);
}
sort(v.begin(), v.end());
long long kk = 0;
long long i;
for (i = 0; i < v.size(); i++) {
if (kk + v[i] > k) {
break;
}
kk += v[i];
}
long long notchangedstreaks = v.size() - i;
cout << 2 * win - notchangedstreaks - 1 << endl;
}
int main() {
long long t;
cin >> t;
while (t--) {
cin >> n >> k;
cin >> s;
solve(n, k, s);
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n,k = map(int,input().split())
arr = list(input())
ind = []
p = -1
if arr[0]=='W':
p = 0
for i in range(1,n):
if arr[i]=='W' and arr[i-1]=='L':
if p!=-1:
ind.append([i-p-1,[p,i]])
p = i
else:
p = i
elif arr[i]==arr[i-1]=='W':
p = i
ind.sort()
for i in ind:
if k==0:
break
else:
for j in range(i[1][0]+1,i[1][1]):
if k:
arr[j] = 'W'
k -= 1
else:
break
if k:
if arr[0]!='W':
if 'W' in arr:
for i in range(arr.index('W')-1,-1,-1):
if k:
arr[i] = 'W'
k -= 1
else:
break
if k:
if arr[-1]!='W':
x = n
for i in range(n-1,-1,-1):
if arr[i]=='W':
x = i
break
for i in range(x+1,n):
if k:
arr[i] = 'W'
k -= 1
else:
break
if k:
for i in range(n):
if k:
arr[i] = 'W'
k -= 1
else:
break
# if k:
# for i in range(1,n-1):
# if k:
# if arr[i]=='L' and (arr[i-1]=='W' or arr[i+1]=='W'):
# arr[i] = 'W'
# k -= 1
# else:
# break
# if k:
# for i in range(n):
# if k:
# if arr[i]=='L':
# arr[i] = 'W'
# k-=1
# print(arr)
ans = int(arr[0]=='W')
for i in range(1,n):
if arr[i]=='W':
if arr[i-1]=='W':
ans += 2
else:
ans += 1
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k, c[100010];
char s[100010];
int main() {
scanf("%d", &t);
while (t--) {
int cnt = 0, ans = 0, d = -1;
scanf("%d%d%s", &n, &k, s);
for (int i = 0; i < n; i++) {
if (s[i] == 'W') cnt++;
if (s[i] == 'L') ans++;
if (s[i] == 'W' && (i == 0 || s[i - 1] == 'L')) c[++d] = ans, ans = 0;
}
if (d > 1) sort(c + 1, c + d + 1);
int i, p = k;
for (i = 1; i <= d && k >= c[i]; k -= c[i], i++)
;
cout << max(0, 2 * min(n, cnt + p) - (max(0, d) - i + 2)) << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cw = 0;
vector<int> blocks1, blocks2;
int cur = 0;
for (int i = 0; i < n; i++) {
if (s[i] != 'W') continue;
int j = i;
while (j < n && s[j] == 'W') j++;
j--;
cur++;
i = j;
}
if (cur == 0) {
cout << max(0, 2 * k - 1) << "\n";
continue;
}
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
cw++;
continue;
}
int j = i;
while (j < n && s[j] == 'L') j++;
j--;
int len = j - i + 1;
if (0 < i && j + 1 < n)
blocks2.push_back(len);
else
blocks1.push_back(len);
i = j;
}
sort(blocks2.begin(), blocks2.end());
cw = min(n, cw + k);
for (int x : blocks2) {
if (x > k) break;
k -= x;
cur--;
}
cout << 2 * cw - cur << "\n";
}
return 0;
}
| 8 | CPP |
T = int(input())
for case in range(T):
#i = int(input())
#
m,n = [int(x) for x in input().split()]
s = input()
# lefts = 0
# try:
# start = s.index("w")
# lefts += start
# s = s[start:]
# except:
# pass
# try:
# end = s.index("w")
# lefts += len(s) - 1 0 end
# s = s[:end+1]
# except:
# pass
#ls = [int(x) for x in input().split()]
#s = sum(ls)
#print("----")
lsw = sorted([x for x in s.split("L") if len(x)])
points = 0
for e in lsw:
points += len(e) * 2 - 1
#print("p",points,lsw)
ll = [x for x in s.split("W") if len(x)]
#print(ll)
ends = 0
if s[0] == "L":
ends += len(ll.pop(0))
if len(ll) and s[-1] == "L":
ends += len(ll.pop())
ls = sorted(ll)
#print(n,ls,ends)
c = 0
full = True
for e in ls:
if n >= len(e):
n -= len(e)
c += len(e) * 2 + 1
else:
c += n * 2
n = 0
full = False
#print("no front back",c,n,ends)
if n != 0:
c += min(n,ends) * 2
if "W" not in s:
c -= 1
#print("front back",c,n)
print(c+points) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class R {
public:
long long s;
long long e;
long long val;
long long dir;
};
bool mycmp(R a, R b) {
if (a.val == b.val) {
return (a.e - a.s + 1) < (b.e - b.s + 1);
}
return a.val > b.val;
}
int main() {
long long t;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
cnt++;
}
}
if (cnt > k && cnt < n) {
vector<R> v;
long long idx = 0;
while (idx < n) {
if (s[idx] == 'L') {
R r;
r.s = idx;
r.e = idx;
while (idx + 1 < n && s[idx + 1] == 'L') {
r.e = idx + 1;
idx++;
}
r.dir = 1;
long long diff = r.e - r.s + 1;
if (r.s == 0) {
r.val = 0;
} else if (r.e == n - 1) {
r.val = 0;
r.dir = 0;
} else {
r.val = 1;
}
v.push_back(r);
idx++;
} else {
idx++;
}
}
sort(v.begin(), v.end(), mycmp);
while (k > 0) {
for (auto vv : v) {
if (vv.dir == 1) {
for (int i = vv.e; i >= vv.s && k > 0; i--) {
s[i] = 'W';
k--;
}
} else {
for (int i = vv.s; i <= vv.e && k > 0; i++) {
s[i] = 'W';
k--;
}
}
}
}
}
if (k > 0) {
for (int i = 0; i < n && k > 0; i++) {
if (s[i] == 'L') {
s[i] = 'W';
k--;
}
}
}
long long score = 0;
if (s[0] == 'W') {
score = 1;
}
for (int i = 1; i < n; i++) {
if (s[i - 1] == 'W' && s[i] == 'W') {
score += 2;
} else if (s[i] == 'W') {
score += 1;
}
}
cout << score << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int t;
for (cin >> t; t--;) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int rem = k;
vector<pair<int, int>> dist;
int prev = -1;
for (int i = 0; i < n; i++) {
if (s.at(i) == 'W') {
if (prev != -1) {
pair<int, int> ins;
ins.first = i - prev - 1;
ins.second = prev + 1;
if (ins.first > 0) {
dist.push_back(ins);
}
}
prev = i;
}
}
sort(dist.begin(), dist.end());
for (pair<int, int> &v : dist) {
if (rem - v.first >= 0) {
rem -= v.first;
for (int i = v.second; i < v.second + v.first; i++) {
assert(i < n);
s.at(i) = 'W';
}
}
}
for (int i = 1; i < n; i++) {
if (rem > 0 and s.at(i) == 'L' and s.at(i - 1) == 'W') {
s.at(i) = 'W';
rem--;
}
}
for (int i = n - 2; i >= 0; i--) {
if (rem > 0 and s.at(i) == 'L' and s.at(i + 1) == 'W') {
rem--;
s.at(i) = 'W';
}
}
for (int i = 0; i < n; i++) {
if (rem > 0 and s.at(i) == 'L') {
s.at(i) = 'W';
rem--;
}
}
int score = 0;
for (int i = 0; i < n; i++) {
if (s.at(i) == 'W') {
score++;
if (i > 0 and s.at(i - 1) == 'W') {
score++;
}
}
}
cout << score << endl;
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
check = [0]*(n+1)
loose = 0
a, b = 0, 0
wins, win_streak = 0, 1
c = 0
for i in s:
if i == 'L':
c += 1
else:
break
for i in range(c, n):
if s[i] == 'W':
wins += 1
if loose > 0:
check[loose] += 1
loose = 0
else:
loose += 1
if i < n-1:
if s[i:(i+2)] == 'WL' and b == 0:
a = 1
if s[i:(i+2)] == 'LW' and a == 1:
b = 1
if a == 1 and b == 1:
a = b = 0
win_streak += 1
if n - wins > k:
wins += k
for i in range(1, n+1):
temp = i*check[i]
if k >= temp:
k -= temp
win_streak -= check[i]
else:
win_streak -= k // i
break
print(max(2*wins - win_streak, 0))
else:
print(2*n - 1)
| 8 | PYTHON3 |
for _ in range(int(input())):
n,k=map(int,input().split())
ar=list(input())
fro=0
bac=0
li=[]
for i in range(n):
if(ar[i]=='L'):
fro+=1
else:
break
for i in range(1,n+1):
if(ar[-i]=='L'):
bac+=1
else:
break
win=ar.count('W')
if(win==0):
print(max(2*(k-1)+1,0))
elif(win==1):
ind=ar.index('W')
i=ind+1
ans=1
while(i<n and k!=0):
ans+=2
i+=1
k-=1
i=ind-1
while(i>=0 and k!=0):
ans+=2
i-=1
k-=1
print(ans)
else:
count=0
for i in range(fro,n-bac):
if(ar[i]=='L'):
count+=1
else:
li.append(count)
count=0
li.sort()
ans=int(ar[0]=='W')
for i in range(1,n):
if(ar[i]=='W'):
if(ar[i-1]=='W'):
ans+=2
else:
ans+=1
for i in li:
if(i<=k and i!=0):
ans+=2*i+1
k-=i
elif(i!=0):
ans+=2*k
k=0
for i in [fro,bac]:
if(i<=k):
ans+=2*i
k-=i
else:
ans+=2*k
k=0
print(ans) | 8 | PYTHON3 |
import sys
input = sys.stdin.readline
def main():
n, k = map(int, input().split())
string = input().strip()
if "W" not in string:
ans = min(n, k) * 2 - 1
print(max(ans, 0))
return
L_s = []
cnt = 0
bef = string[0]
ans = 0
for s in string:
if s == bef:
cnt += 1
else:
if bef == "L":
L_s.append(cnt)
else:
ans += cnt * 2 - 1
cnt = 1
bef = s
if bef == "W":
ans += cnt * 2 - 1
cnt = 0
if string[0] == "L" and L_s:
cnt += L_s[0]
L_s = L_s[1:]
L_s.sort()
for l in L_s:
if k >= l:
ans += l * 2 + 1
k -= l
else:
ans += k * 2
k = 0
ans += 2 * min(k, cnt)
print(ans)
for _ in range(int(input())):
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, k, count = 0, sum = 0;
cin >> n >> k;
string s;
cin >> s;
for (int j = 0; j < n; j++) {
if (s[j] == 'L') {
count++;
}
}
if (count <= k) {
cout << 2 * n - 1 << endl;
} else {
if (count == n) {
if (k <= 1) {
cout << k << endl;
} else {
cout << 2 * k - 1 << endl;
}
} else {
int p = -1, o = -1;
vector<int> vec = {};
vector<char> vc = {};
if (s[0] == 'W') {
sum += 1;
p = 0;
o = 0;
}
for (int j = 1; j < n; j++) {
if (s[j] == 'W' && s[j - 1] == 'W') {
sum += 2;
} else if (s[j] == 'W' && s[j - 1] == 'L') {
sum += 1;
if (p == 0) {
vec.push_back(vc.size());
vc.clear();
}
p = 0;
if (o == -1) {
o = j;
}
} else if (p == 0 && s[j] == 'L') {
vc.push_back(s[j]);
}
}
sort(vec.begin(), vec.end());
for (int j = 0; j < vec.size(); j++) {
if (k >= vec[j]) {
sum += 2 * vec[j] + 1;
k -= vec[j];
if (k == 0) {
break;
}
} else if (k < vec[j]) {
sum += 2 * k;
k = 0;
break;
}
}
if (k != 0) {
sum += 2 * k;
}
cout << sum << endl;
}
}
}
}
| 8 | CPP |
"""T=int(input())
for _ in range(0,T):
n=int(input())
a,b=map(int,input().split())
s=input()
s=[int(x) for x in input().split()]
for i in range(0,len(s)):
a,b=map(int,input().split())"""
T=int(input())
for _ in range(0,T):
n,k=map(int,input().split())
L=input()
s=[]
for i in range(0,len(L)):
s.append(L[i])
ptr=len(s)
#ptr2=len(s)
for i in range(0,len(s)):
if(s[i]=='W'):
ptr=i
break
dp=[]
c=0
st=ptr
for i in range(ptr+1,len(s)):
if(s[i]=='W'):
if(c>0):
dp.append([c,st+1,i])
st=i
c=0
else:
c+=1
#if(c>0):
#dp.append([c,st+1,len(s)])
dp.sort()
fnl=[]
for i in range(0,len(dp)):
cnt=dp[i][0]
j1=dp[i][1]
j2=dp[i][2]
for j in range(j1,j2):
fnl.append(j)
for i in range(st+1,len(s)):
fnl.append(i)
for i in range(ptr-1,-1,-1):
fnl.append(i)
for i in range(0,min(k,len(fnl))):
s[fnl[i]]='W'
ans=0
prev=0
for i in range(0,len(s)):
if(s[i]=='W'):
if(prev==1):
ans+=2
else:
ans+=1
prev=1
else:
prev=0
print(ans)
"""c=0
for i in range(ptr,len(s)):
if((c+1)<=k and s[i]=='L'):
s[i]='W'
c+=1
for i in range(0,len(s)):
if((c+1)<=k and s[i]=='L'):
s[i]='W'
c+=1
ans=0
prev=0
for i in range(0,len(s)):
if(s[i]=='W'):
if(prev==1):
ans+=2
else:
ans+=1
prev=1
else:
prev=0
print(ans)"""
| 8 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
a=list(input())
s,l=0,0
ind,sp=[],[]
for i in range(n):
if a[i]=="W":
if (i>0 and a[i-1]=="W"):
s+=2
else:
s+=1
ind.append(i)
l+=1
if l>1:
sp.append([ind[-1],ind[-2],ind[-1]-ind[-2]-1])
sp=sorted(sp,key=lambda x: x[2])
if k==0:
print(s)
elif ind==[]:
print(1+2*(min(k-1,n-1)))
else:
k1=[n,ind[-1],n-ind[-1]-1]
k2=[ind[0],-1,ind[0]]
ini=s
if k1[2]>k2[2]:
sp+=[k2,k1]
else:
sp+=[k1,k2]
#print(sp,ini)
l1=len(sp)
for i in range(l1):
if sp[i][2]==0:
continue
if sp[i][0]==n:
if k>=sp[i][2]:
ini+=2*sp[i][2]
k-=sp[i][2]
else:
ini+=2*k
k=0
else:
if k>=sp[i][2]:
ini+=2*(sp[i][2]-1)+2
if sp[i][1]!=-1:
ini+=1
k-=sp[i][2]
else:
ini+=2*(k-1)+2
k=0
if k==0:
break
print(ini)
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
a = input()
bet = []
score = 0
counter = 0
total = 0
flag = -1
for x in a:
if x == "W":
if flag == 0:
bet.append(counter)
counter = 0
if flag <= 0:
score += 1
else:
score += 2
flag = 1
else:
if flag == 1 or flag == 0:
counter += 1
flag = 0
total += 1
if total == n and k > 0:
score = -1
else:
bet.sort()
for x in bet:
if x <= k:
k = k - x
total = total - x
score += (x * 2) + 1
if k > total:
k = total
score += k * 2
print(score) | 8 | PYTHON3 |
# wow, I'm bad
t = int(input())
for _ in range(t):
n,K = map(int,input().split())
s = input()
n = len(s)
def way1():
global n,K,s
if s.find('W') == -1:
return max(0, 2*min(K, n) - 1)
k = K
score = int(s[0] == 'W')
for i in range(1, n):
if s[i-1] == s[i] == 'W':
score += 2
elif s[i] == 'W':
score += 1
loss_streaks = [len(x) for x in s.split('W') if x != '']
if s[0] == 'L':
first = loss_streaks[0]
del loss_streaks[0]
else:
first = 0
if s[-1] == 'L' and loss_streaks:
last = loss_streaks[-1]
del loss_streaks[-1]
else:
last = 0
loss_streaks.sort()
for i in range(len(loss_streaks)):
if loss_streaks[i] <= k:
k -= loss_streaks[i]
score += loss_streaks[i]*2 + 1
loss_streaks[i] = 0
left = sum(loss_streaks)
score += 2*min(left, k)
k -= min(left, k)
if k and last:
score += 2*min(last, k)
k -= min(last, k)
if k and first:
score += 2*min(first, k)
return score
print(way1())
| 8 | PYTHON3 |
import sys
input = sys.stdin.readline
def compress(string):
string = string + "#"
n = len(string)
begin, end, cnt = 0, 1, 1
ans = []
while end < n:
if string[begin] == string[end]:
end, cnt = end + 1, cnt + 1
else:
ans.append((string[begin], cnt))
begin, end, cnt = end, end + 1, 1
return ans
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
s = input()[:-1]
s = compress(s)
w_groups = 0
w_cnt = 0
l_cnt = 0
li = []
for i, (char, cnt) in enumerate(s):
if char == "W":
w_groups += 1
w_cnt += cnt
if char == "L":
l_cnt += cnt
if 1 <= i < len(s) - 1:
li.append(cnt)
if w_cnt == 0:
print(max(min(k, l_cnt) * 2 - 1, 0))
continue
ans = w_cnt * 2 - w_groups
ans += min(k, l_cnt) * 2
li.sort()
for val in li:
if k >= val:
ans += 1
k -= val
print(ans) | 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
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 inp():
return sys.stdin.readline()
def mpint():
return map(int, sys.stdin.readline().split(' '))
def itg():
return int(sys.stdin.readline())
# ############################## import
def rindex(array, value):
for i in range(len(array) - 1, -1, -1):
if array[i] == value:
return i
raise ValueError("{} is not in list".format(value))
# ############################## main
from collections import Counter, defaultdict, deque
from itertools import accumulate
def solve():
n, k = mpint()
s = list(inp())
w = s.count('W')
L = n - w
if w <= 1:
return max(0, min(n, (k + w)) * 2 - 1)
for i in range(1, n - 1):
if not k:
break
if s[i] == 'L' and s[i - 1] == s[i + 1] == 'W':
s[i] = 'W'
k -= 1
L -= 1
ans = 1 if s[0] == 'W' else 0
for i in range(1, n):
if s[i] == 'W':
if s[i - 1] == 'W':
ans += 2
else:
ans += 1
lose = []
c = 0
for i in range(s.index('W') + 1, rindex(s, 'W') + 1):
if s[i] == 'W':
if c:
lose.append(c)
c = 0
else:
c += 1
lose.sort(reverse=True)
while k and lose:
c = lose.pop()
if k >= c:
ans += c * 2 + 1
k -= c
L -= c
else:
ans += k * 2
k = 0
ans += min(k, L) * 2
return ans
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if __name__ == '__main__':
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# print(solve())
# solve()
for _ in range(itg()):
print(solve())
# solve()
# Please check!
| 8 | PYTHON3 |
from collections import defaultdict
T = int(input())
for t in range(T):
n, k = map(int, input().split())
s = input()
ko = k
curr = 0
if s[0] == 'W':
curr += 1
gaps = defaultdict(int)
gap = 0
for i in range(1,n):
if s[i] == "W":
gaps[gap] += 1
gap = 0
curr+=1
if s[i-1] == "W":
curr += 1
else:
gap += 1
if curr == 0:
if k!=0:
curr -= 1
else:
fg = s.index("W")
if fg > 1:
gaps[fg-1] -= 1
gaps_filled = 0
for x,y in sorted(gaps.items()):
if x == 0:
continue
if k//x >= y:
gaps_filled += y
k -= y*x
else:
gaps_filled += k//x
break
ko = min(ko, s.count("L"))
ans = curr+ ko*2 + gaps_filled
print(ans)
# print(gaps,"\n######")
| 8 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip()
for _ in range(int(input())):
n,k=[int(i) for i in input().split()]
s=[i for i in input()]
if s.count('W')==0:
print(max(2*k-1,0))
continue
if s[0]=='W': ans=1
else: ans=0
for i in range(1,n):
if s[i-1]=='W' and s[i]=='W':
ans+=2
elif s[i-1]=='L' and s[i]=='W':
ans+=1
beg=0; end=0
while s and s[-1]=='L':
end+=1
s.pop()
s.reverse()
while s and s[-1]=='L':
beg+=1
s.pop()
s.reverse()
cnt=[]
for i in range(1,len(s)):
if s[i]=='L' and s[i-1]=='W':
cnt.append(1)
elif s[i]=='L' and s[i-1]=='L':
cnt[-1]+=1
cnt.sort()
cnt.reverse()
while k and cnt:
if k>=cnt[-1]:
k-=cnt[-1]
ans+=2*cnt[-1]+1
cnt.pop()
else:
ans+=2*k
k=0
cnt.pop()
ans+=2*min(k,end)
k-=min(k,end)
ans+=2*min(k,beg)
k-=min(k,beg)
print(ans)
| 8 | PYTHON3 |
from collections import *
t = int(input())
while t:
t-= 1
n,k = [int(x) for x in input().split()]
s = input()
if 'W' not in s:
print(max(0,1+2*(k-1)))
else:
startl = s.find('W')
endl=s[::-1].find('W')
terminal = startl + endl
nns = ['W']
ans = 0
for i in range(startl+1,n - endl):
if s[i-1] == 'W' and s[i]=='W':
ans += 2
else:
# nns += s[i]
nns.append(s[i])
s = "".join(nns)
n = len(s)
d = defaultdict(lambda : 0)
pre = 0
for i in range(1, n):
if s[i] == 'W':
d[i-pre-1] += 1
pre = i
# print(d)
ns = ["W"]
nrr = []
for key in d:
nrr.append([key,d[key]])
nrr.sort()
for i,j in nrr:
ns.append(('L'*i +'W')*j)
ns = "".join(ns)
# print(ns)
def score():
ans= 1
left = k
N = len(ns)
pre = False
for i in range(1,N):
if ns[i] == 'W':
if pre or ns[i-1] == 'W':
ans += 2
else:
ans += 1
continue
if left == 0:
pre = False
continue
pre =True
ans += 2
# if i+1 < N and ns[i+1] == 'W':
# ans += 1
left -= 1
return [ans,left]
# print(['multiple w', ans])
temp,left = score()
ans += temp
# print(['grredy ', temp])
# print(['terminal'terminal])
ans += 2*(min(left,terminal))
# print(['remaning ', 2*(min(left,terminal))])
print(max(ans,0))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
char c[100001];
void solve() {
int n, k;
scanf("%d%d%s", &n, &k, c);
vector<array<int, 3>> l;
for (int i = 0; i < n; ++i) {
if (c[i] == 'W') {
if (i && c[i - 1] == 'L') l.back()[1] = i - 1;
} else {
if (l.empty() || c[i - 1] == 'W') l.push_back({i, 0, (int)l.size()});
}
}
if (c[n - 1] == 'L') l.back()[1] = n - 1;
if (l.size() == 0) {
printf("%d\n", n * 2 - 1);
return;
}
sort(l.begin(), l.end(), [&](array<int, 3> a, array<int, 3> b) -> bool {
if (a[0] == 0 || a[1] == n - 1) return false;
if (b[0] == 0 || b[1] == n - 1) return true;
return a[1] - a[0] < b[1] - b[0];
});
for (auto [start, end, i] : l) {
int d = end - start + 1;
if (k > d) {
k -= d;
for (int j = start; j <= end; ++j) c[j] = 'W';
} else {
if (start == 0)
for (int j = end, x = 0; x < k; --j, ++x) c[j] = 'W';
else
for (int j = start; j < start + k; ++j) c[j] = 'W';
break;
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (c[i] == 'W') {
if (i && c[i - 1] == 'W')
ans += 2;
else
++ans;
}
}
printf("%d\n", ans);
}
int main() {
int tc = 1;
scanf("%d", &tc);
for (int i = 1; i <= tc; ++i) {
solve();
}
}
| 8 | CPP |
t=input
for i in range(int(t())):
n,k=map(int,t().split())
a=sorted(map(len,t().strip('L').split('W')))
m=len(a)+k
while a and k>=a[0]:
k-=a.pop(0)
print((2*min(n,m-1)-len(a) or 1)-1) | 8 | PYTHON3 |
import os
import sys
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)
def input(): return sys.stdin.readline().rstrip("\r\n")
t = int(input())
for _ in range(t):
n,k = [int(i) for i in input().split()]
s = input()
if s.count('L') == len(s):
if k:
score = min(k-1,len(s)-1)*2+1
else:
score = 0
print(score)
continue
f = False
lc = 0
totl = 0
# lw = 0
d = []
score = 0
for p,i in enumerate(s):
if i=='L':
lc+=1
totl+=1
else:
if lc:
if f:
d.append(lc)
lc = 0
f = True
if p and s[p-1]=='W':
score+=2
else:
score+=1
d.sort(reverse=True)
while d:
if k>=d[-1]:
totl-=d[-1]
k-=d[-1]
score+=1+2*d[-1]
d.pop()
else:
break
score+=min(totl,k)*2
print(score) | 8 | PYTHON3 |
import sys
input = iter(sys.stdin.read().splitlines()).__next__
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
s = input()
num_losses = s.count("L")
if k >= num_losses:
print(2*n-1)
continue
# initial = 'L' if
# dp = [[] for _ in range(k)]
# greedily change losses before wins, then losses after wins
# try to get entire intervals changed
score = 1 if s[0] == "W" else 0
interval_lengths = [] if s[0] == "W" else [0]
for i in range(1, n):
if s[i] == "W":
if s[i-1] == "W":
score += 2
else:
score += 1
interval_lengths[-1] += i
elif s[i-1] == "W":
interval_lengths.append(-i)
if s[-1] == "L":
last_length = interval_lengths.pop()
last_length += n
else:
last_length = 0
if s[0] == "L" and interval_lengths:
first_length = interval_lengths.remove(interval_lengths[0])
if sum(interval_lengths) <= k:
# only will be missing some things from last_length or first_length
# so contiguous wins
num_wins = s.count("W") + k
print(max(2*num_wins-1, 0))
continue
interval_lengths.sort(reverse=True)
# print(interval_lengths)
while k:
next_interval = interval_lengths.pop()
if k >= next_interval:
k -= next_interval
score += 2*next_interval+1
else:
score += 2*k
k = 0
# print("hello", score)
print(score) | 8 | PYTHON3 |
######################################################
############Created by Devesh Kumar###################
#############[email protected]####################
##########For CodeForces(Devesh1102)#################
######################################################
import sys
import heapq
import copy
import math
import decimal
input = sys.stdin.readline
# import sys.stdout.flush as flush
# from decimal import *
#heapq.heapify(li)
#
#heapq.heappush(li,4)
#
#heapq.heappop(li)
#
# & Bitwise AND Operator 10 & 7 = 2
# | Bitwise OR Operator 10 | 7 = 15
# ^ Bitwise XOR Operator 10 ^ 7 = 13
# << Bitwise Left Shift operator 10<<2 = 40
# >> Bitwise Right Shift Operator
# '''############ ---- Input Functions ---- #######Start#####'''
# n = 100
# parent = [-1 for i in range(n)]
# def find(a):
# if parent[a] == a:
# return a
# else:
# parent[a] = find(parent[a])
# def union(a,b):
def binary_exponentiation(a,b):#a^b
ans = 1
while(b!=0):
bit = b%2
if bit == 1:
ans =ans*a
a = a*a
b = b//2
return ans
# print(lsp )
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def insr2():
s = input()
s = list(s[:len(s) - 1])
s = [ord(s[i]) - ord("a") for i in range(len(s))]
return s
def invr():
return(map(int,input().split()))
############ ---- Input Functions ---- #######End
# #####
ans = 0
def pr_list(a):
print( *a , sep=" ")
def swap(a,b):
temp = a
a = b
b = temp
return [ a,b]
# return [b,a]
def pri(a,b):
s = "? " + str(a) + " " + str(b)
print(s)
sys.stdout.flush()
result = []
def nCk(arr,itr,k,n):
if len(arr) == k:
result.append(arr)
return
if len(arr)>k or itr == n+1:
return
nCk(arr + [itr],itr+1,k,n)
nCk(arr,itr+1,k,n)
return
def nPk(arr,itr,k,n):
if len(arr) ==k:
result.append(arr)
return
if len(arr)>k or itr == n+1:
return
for i in range(len(arr)+1):
nPk(arr[0:i] + [itr] + arr[i: len(arr)],itr+1,k,n)
nPk(arr,itr+1,k,n)
return
def main():
tests = inp()
# tests = 1
# mod = 998244353
mod = 1000000007
limit = 10**18
ans = 0
stack = []
arr = []
heapq.heapify(arr)
# print(dp)
for test in range(tests):
n,k = inlt()
s= insr()
change = []
left = 0
start= 0
for i in range(n):
if s[i] == "W":
start = i
break
left = left + 1
pre = start
for i in range(start,n):
if s[i] == "W":
if (i - pre) > 0:
change.append([i-pre-1,pre +1,i-1])
pre = i
change.sort()
# print(start,change)
for m in change:
[val,i,j] = m
for n in range(i,j+1):
if k == 0:
break
s[n] ="W"
k = k -1
if k == 0:
break
# print(s,1)
for m in range(start-1,-1,-1):
if k == 0:
break
s[m] = "W"
k = k- 1
# print(s,2)
for m in range(0,len(s)):
if k == 0:
break
if s[m] == "L":
s[m] = "W"
k = k- 1
# print(s,3)
score = 0
streak = 0
for i in s:
if i == "W":
if streak == 1:
score = score + 2
else:
score= score + 1
streak = 1
else:
streak = 0
print(score)
if __name__== "__main__":
main()
# return least index x such that A[x] > target, or len(A) if no such index exists | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string in;
cin >> in;
int score = 0;
int totl = 0;
for (int i = 0; i < (n); ++i)
if (in[i] == 'L') totl++;
if (totl == n) {
if (k == 0)
cout << 0 << '\n';
else
cout << 2 * min(n, k) - 1 << '\n';
continue;
}
for (int i = 0; i < (n); ++i) {
if (i == 0) {
if (in[i] == 'W') score++;
} else {
if (in[i] == 'W') {
if (in[i - 1] == 'W')
score += 2;
else
score++;
}
}
}
int s = 0, e = 0;
bool og = false;
vector<int> ps;
while (s < n) {
if (in[s] == 'L') {
s++;
} else {
e = s + 1;
while (e < n && in[e] == 'L') e++;
if (e - s - 1 == 0 || e == n) {
s++;
continue;
}
ps.push_back(e - s - 1);
s = e;
}
}
sort(ps.begin(), ps.end());
for (int it : ps) {
if (k >= it) {
k -= it;
totl -= it;
score += 2 * it + 1;
} else {
score += 2 * k;
totl -= k;
k = 0;
break;
}
}
if (k != 0) score += 2 * min(k, totl);
cout << score << '\n';
}
return 0;
}
| 8 | CPP |
t=int(input())
for qwe in range(t):
[n,k]=[int(j) for j in input().split()]
s=input()
l=list(s)
c=0
a=[]
if l[0]=="W":
ans=1
else:
ans=0
for i in range(1,n):
if l[i]=="W":
if l[i-1]=="W":
ans+=2
else:
ans+=1
m=-1
fl=[]
for i in range(n):
if l[i]=="W":
if m==0 and c>0:
a.append(c)
elif c>0:
fl.append(c)
c=0
m=0
else:
c+=1
fl.append(c)
a.sort()
for j in a:
if k>=j:
ans+=(2*j+1)
k-=j
else:
ans+=2*k
k=0
if ans==0:
ans=max(2*k-1,0)
else:
ans+=2*(min(sum(fl),k))
print(ans) | 8 | PYTHON3 |
I=input
for _ in[0]*int(I()):
n,k=map(int,I().split());s=I();a=sorted(map(len,filter(None,s.strip('L').split('W'))));r=k
while a and a[0]<=r:r-=a.pop(0)
print((2*min(n,s.count('W')+k)-len(a)or 1)-1) | 8 | PYTHON3 |
def score(a,n):
score = 0 if a[0]=='L' else 1
for i in range(1,n):
if a[i]==a[i-1] =='W':
score+=2
elif a[i]=='W':
score+=1
return score
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
s = input()
mylist = []
x = 0
while(x<n and s[x]=='L'):
x+=1
count = 0
while(x<n):
if(s[x]=='W'):
if count!=0:
mylist.append(count)
count=0
else:
count+=1
x+=1
mylist.sort()
ans = 0
for i in mylist:
k-=i
if k==0:
ans+= 2*i + 1
break
elif k>0:
ans+=2*i+1
else:
ans+=2*i
break
counter = 0
while(counter<n and s[counter]=='L'):
counter+=1
scounter = 0
while( scounter<n and s[n-1-scounter]=='L' ):
scounter+=1
ans+=score(s,n)
if ans==0 and k>0:
ans-=1
if k<=(scounter+counter):
ans+=2*k
else:
ans+=2*(scounter+counter)
# print("ans",ans)
print(ans)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long a,b,c,d,e,f,g,h,i,j,k,l,m,n,x,y,z,t;
cin>>t;
while(t--)
{
cin>>a>>b;
pair<long long,long long>pp[a+1];
map<long long,long long>mp[a+1];
for(i=1; i<=a; i++)
{
cin>>c>>d;
pp[i]=make_pair(c,d);
long ct=0;
if(i>1)
{
for(j=1; j<i; j++)
{
if(abs(pp[i].first-pp[j].first)+abs(pp[i].second-pp[j].second)<=b)
{
// cout<<i<<" *** "<<j <<" "<<abs(pp[i].first-pp[j].first)+abs(pp[i].second-pp[j].second)<<endl;
mp[i][j]=1;
mp[j][i]=1;
}
}
}
}
f=0;
for(i=1; i<=a; i++)
{
if(mp[i].size()==a-1)
{
cout<< "1"<<endl;
f=1;
break;
}
}
if(f==0)
cout<<"-1"<<endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n,k;
cin>>n>>k;
ll a[n][2];
for(ll i=0;i<n;i++)
cin>>a[i][0]>>a[i][1];
ll ans=-1;
bool flag=0;
for(ll i=0;i<n;i++)
{
flag=0;
for(ll j=0;j<n;j++)
{
if((abs(a[i][0]-a[j][0])+abs(a[i][1]-a[j][1]))>k)
{
flag=1;
break;
}
}
if(flag==0)
{
ans=1;
break;
}
}
cout<<ans<<"\n";
}
}
| 8 | CPP |
# cook your dish here
remaing_test_cases = int(input())
while remaing_test_cases > 0:
points_count,K = map(int,input().split())
points = []
for i in range(points_count):
x,y = map(int,input().split())
points.append([x,y])
flag = 0
for i in range(points_count):
count_power = 0
for j in range(points_count):
if (abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])) <= K:
count_power = count_power + 1
if count_power == points_count:
print(1)
flag = 1
break
if flag == 0:
print(-1)
remaing_test_cases = remaing_test_cases - 1 | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
/*vector<int>v;
void SieveOfEratosthenes(int n)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
v.push_back(p);
}
int binarySearch( int l, int r, int x)
{
if (r >= l) {
int mid = l + (r - l) / 2;
if (v[mid] == x)
return mid;
if (v[mid] > x)
return binarySearch( l, mid - 1, x);
return binarySearch( mid + 1, r, x);
}
} */
/*
// adjacency matrix
bool adjMatrixBool[N][N]; // boolean relation
int adjMatrix[N][N];
vector<int> adjMatrixAll[N][N]; // Keep all edges for a given pair of nodes
// Adjacency lists
vector< vector<int> > adjList1;
vector< vector< pair<int, int> > > adjList2; // cost relation (node, cost): Select 1
of multiple edges
*/
/*
void DFS_Mat(int u) {
vis[u] = 1;
for(int v=0;v<=n;v++)
if(adjMat[u][v] == 1 && vis[v] == 0)
DFS_Mat(v);
}
void DFS_List(int u) {
vis[u] = 1;
for( int v : adjList[u]){
if (vis[v] == 0)
DFS_List(v);
}
}
*/
/*
vector<int> BFS2(int s) {
vector<int> len(adjList.size(), 1e6);
queue<int> q;
q.push(s), len[s] = 0;
int dep = 0, cur = s, sz = 1;
for ( ; !q.empty(); ++dep, sz = q.size()) {
while (sz--) {
cur = q.front(), q.pop();
for(int i=0;i< adjList[cur].size();)
if (len[adjList[cur][i]] == 1e6)
q.push(adjList[cur][i]), len[adjList[cur][i]] = dep+1;
} }
return len; //cur is the farthest node from s with depth dep
}
*/
/*
Backtracking(state)
* if invalid(state) //e.g. the location is already visited or we reached to the end
* return
*
* if found_solution(state)
* mark_solution_found
* return
*
* for each child_state of state
* state' = do changes in state
*
* Backtracking(state')
*
* state = undo changes in state'
*/
/*
bool isPrime(long long n){
if(n < 2)
return false;
//Check all numbers from 2->root(N)
//If it is a divisor of n
for (long long i=2; i*i <= n; i++) // O(root(N))
if (n % i == 0)
return false;
return true;
}
vector<int>Primes;
void Sieve(int n)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
Primes.push_back(p);
}
*/
/*
int GCD (int a,int b){
if (b==0)
return a;
return GCD (b, a % b);
}
int LCM(int a,int b){
return a / GCD(a, b) * b;
// Avoid (a*b) / GCD(a,b) may overflow
}
*/
/*
int BinarySearch(int num) {
int st = 0, en = v.size() - 1;
while(st <= en) {
int mid = (st + en) >> 1;
if(v[mid] == num)
return mid;
if(v[mid] < num)
st = mid + 1;
else if(v[mid] > num)
en = mid - 1;
}
return -1;
}
*/
/*
Count Number of ones in binary representation
int cntBits = __builtin_popcount(num);
__builtin_popcountll(num) for long long
Check bit (Zero or One):
if(((mask >> bitIndx) & 1) == 1)
Set bit to One:
mask |= (1 << bitIndx);
Set bit to Zero:
mask &= ~(1 << bitIndx);
Toggle bit :
mask ^= (1 << bitIndx);
Check if number is Even or Odd:
if(num & 1 == 1) (num & 1) = num%2
cout << "ODD";
if(num & 1 == 0)
cout<<"EVEN";
*/
/*
char xyz[n];
for(int msk = 0; msk < (1 << n); msk++) {
for(int ind = 0; ind < n; ind++)
if((msk >> ind) & 1)
cout << xyz[ind];
cout << endl;
}
if(mp.count(str))
{
mp[str]++;
}
else {
mp[str]++;
}
priority_queue<int>pq;
priority_queue <int, vector<int>, greater<int>>pq2;
*/
/*
map<int,int>mpp;
for(cin>>N;i<N;i++){
cin>>arr[i];
r=mpp[arr[i]]=mpp[arr[i]-1]+1;
if(r>k)k=r,last=arr[i];
}
cout<<k<<endl,t=last-k+1;
for(i=0;i<N;i++)
if(arr[i]==t)cout<<i+1<<" ",t++;
*/
/*
vector<int> adjList1[10];
vector<int> len(10, 1e6);
void BFS2(int s) {
queue<int> q;
q.push(s), len[s] = 0;
int dep = 0, cur = s, sz = 1;
for ( ; !q.empty(); ++dep, sz = q.size()) {
while (sz--) {
cur = q.front(), q.pop();
for(int i=0;i< adjList1[cur].size();i++)
if (len[adjList1[cur][i]] == 1e6)
q.push(adjList1[cur][i]), len[adjList1[cur][i]] = dep+1;
} }
}
*/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--){
int n,k;
cin>>n>>k;
int x[n],y[n];
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
}
int d=0,cx=0,cy=0;int v=0;
for(int i=0;i<n;i++){
cx=0,cy=0;
for(int j=0;j<n;j++){
if(i==j)continue;
d=abs(x[i]-x[j]);
d+=abs(y[i]-y[j]);
if(d>k){
v++;break;}
}
}
if(v!=n)
cout<<1<<endl;
else cout<<-1<<endl;
}
} | 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, k;
pair<int, int> adj[N];
int ans;
bool Checks(int i, int j) {
return abs(adj[i].first - adj[j].first) + abs(adj[i].second -adj[j].second) <= k;
}
int main()
{
//freopen("in.txt", "r", stdin);
//freopen(".inp", "r", stdin);
//freopen(".out", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t; cin >> t;
while(t--) {
cin >> n >> k;
for(int i = 0; i < n; ++i)
cin >> adj[i].first >> adj[i].second;
ans = 0;
bool check = false;
vector<bool> chos(n);
for(int k = 0; k < n; ++k) {
vector<int> best;
for(int i = 0; i < n; ++i) {
if(chos[i]) continue;
vector<int> att;
for(int j = 0; j < n; ++j) {
if(i == j) continue;
if(chos[j]) continue;
if(Checks(i, j)) att.push_back(j);
}
if(att.size() > best.size())
best.swap(att);
}
if(best.empty()) {
check = true; break;
}
for(auto x : best)
chos[x] = true;
ans++;
if(count(chos.begin(), chos.end(), false) == 1)
break;
}
if(!check) cout << ans << '\n';
else cout << -1 << '\n';
}
return 0;
}
| 8 | CPP |
from os import path
import sys
# mod = int(1e9 + 7)
# import re # can use multiple splits
from math import ceil, floor,gcd,log
from collections import defaultdict , Counter
# from bisect import bisect_left, bisect_right
#popping from the end is less taxing,since you don't have to shift any elements
maxx = float('inf')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
I = lambda :int(sys.stdin.buffer.readline())
tup= lambda : map(int , sys.stdin.buffer.readline().split())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().replace('\n', '').strip()
# def grid(r, c): return [lint() for i in range(r)]
# def debug(*args, c=6): print('\033[3{}m'.format(c), *args, '\033[0m', file=sys.stderr)
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
star = lambda x: print(' '.join(map(str, x)))
else:
#------------------PYPY FAst I/o--------------------------------#
I = lambda :int(sys.stdin.buffer.readline())
tup= lambda : map(int , sys.stdin.buffer.readline().split())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().replace('\n', '').strip()
# def grid(r, c): return [lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
star = lambda x: print(' '.join(map(str, x)))
# input = sys.stdin.readline
for _ in range(I()):
n , k = tup()
a=[]
for i in range(n):
b ,c = tup()
a.append((b,c))
ans = maxx
for i in range(n):
se = set()
f = 1
for j in range(n):
if i != j :
ana = abs(a[i][0] - a[j][0]) + abs(a[i][1] - a[j][1])
if ana <= k:
se.add(ana)
else:
f =0
break
if f:
ans= min(ans ,len(se))
se.clear()
else:
se.clear()
if ans == maxx:
print(-1)
else:print(1)
| 8 | PYTHON3 |
import math
from collections import defaultdict
from sys import stdin
input=stdin.readline
T=int(input())
for _ in range(T):
n,k=map(int,input().split())
mat=[]
for i in range(n):
lis=list(map(int,input().split()))
mat.append(lis)
lim=len(mat)
f=0
for i in range(lim):
c=0
for j in range(lim):
ch=abs(mat[i][0]-mat[j][0])+abs(mat[i][1]-mat[j][1])
if ch<=k:
c+=1
if c==n:
f=1
break
if f:
print(1)
else:
print(-1)
| 8 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
xs=[]
ys=[]
for ii in range(n):
x,y=map(int,input().split())
xs.append(x)
ys.append(y)
#print(xs)
#print(ys)
done=False
for i in range(n):
max_k=-1
for j in range(n):
max_k = max(max_k, abs(xs[i]-xs[j]) + abs(ys[i]-ys[j]))
if max_k<=k:
print(1)
done=True
break
if not done:
print(-1)
| 8 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <sstream>
#include <queue>
#include <list>
#include <climits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define all(v) v.begin(),v.end()
struct p {
int a;
int b;
};
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int tc = 1;
cin>>tc;
while (tc--) {
int n, k, j; cin >> n >> k;
vector<p> vec(n);
bool ok = 0;
for (p& j : vec) {
cin >> j.a >> j.b;
}
for (int i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (abs(vec[i].a - vec[j].a) + abs(vec[i].b - vec[j].b)>k)
break;
}
if (j == n) {
ok = 1; break;
}
}
if (ok && k)cout << 1 << endl;
else cout << -1 << endl;
}
return 0;
} | 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define absdiff(a,b) (a>b)?a-b:b-a
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define fast ios_base::sync_with_stdio(false);cin.tie(0);
#define MOD 1000000007
#define ll_MAX 19223372036859
#define endl "\n"
ll fast_expo(ll x,ll p){
if(p==0) return 1;
else if(p%2==0){ ll t=fast_expo(x,p/2)%MOD;return (t*t)%MOD;}
else return (x*(fast_expo(x,p-1))%MOD)%MOD;}
int main(){
fast
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t_c; t_c = 1;
cin >> t_c;
for(ll t_i = 0; t_i < t_c; ++t_i){
ll n, k; cin >> n >> k;
ll ans = -1;
vector<ll> AdjL[n];
pair<ll, ll> arr[n];
for(ll i = 0; i < n; ++i){
cin >> arr[i].ff >> arr[i].ss;
}
for(ll i = 0; i < n; ++i){
ll flag = 1;
for(ll j = 0; j < n; ++j){
ll dis = abs(arr[j].ff - arr[i].ff) + abs(arr[j].ss - arr[i].ss);
if(dis > k){
flag = 0;
break;
}
}
if(flag){
ans = 1;
break;
}
}
cout << ans << endl;
}
return 0;
} | 8 | CPP |
def ass(a, b):
if a != b: print(f"Assertion error: {a} != {b}")
else: print('OK')
def number(): return int(input())
def numbers(): return [int(item) for item in input().split()]
def word(): return input()
def words(): return [item for item in input().split()]
def dump(lst):
for i, item in enumerate(lst): print(i, item)
def binsearch(arr, a, b):
m = (a + b) // 2
if a >= b: return a - 1 if arr[a] == 0 else a
return binsearch(arr, a, m - 1) if arr[m] == 0 else binsearch(arr, m + 1, b)
def f(k,balls):
flag = 1
for x0,y0 in balls:
for x1,y1 in balls:
if abs(x0-x1) + abs(y0-y1) > k:
flag = -1
break
else:
flag = 1
break
return flag
for t in range(number()):
n,k = numbers()
balls = [numbers() for i in range(n)]
print(f(k,balls))
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
li = []
ans = -1
for i in range(n):
li.append(list(map(int, input().split())))
for i in range(n):
ok = True
for j in range(n):
if i!=j and k<abs(li[i][0]-li[j][0])+ abs(li[i][1]-li[j][1]):
ok = False
break
if ok:
ans = 1
break
print(ans)
| 8 | PYTHON3 |
for _ in range(int(input())):
n, k = list(map(int, input().split()))
a = []
yes = 1
for i in range(n):
a.append(list(map(int, input().split())))
for i in range(n):
yes = 0
for r in range(n):
if abs(a[i][0] - a[r][0]) + abs(a[i][1] - a[r][1]) > k:
yes = 1
if yes == 0:
break
if yes == 0:
print(1)
else:
print(-1)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
#define ll long long
#define vll vector<ll>
#define pb push_back
#define eb emplace_back
#define sll set<ll>
#define ins insert
#define rep(i,n) for(int i=0;i<n;i++)
#define vpp vector<pair<int,int>>
#define mp make_pair
#define ft first
#define sc second
#define gp " ";
#define MAX 9999999
#define MOD 1000000007
#define mnn(v2) *min_element(v2.begin(),v2.end());
#define mxx(v2) *max_element(v2.begin(),v2.end());
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t=1;
cin>>t;
while(t--)
{
ll x,y,i,j,k,c=0,mx=0,m,n;
cin>>n>>k;
ll a[n],b[n];
for(i=0; i<n; i++)
cin>>a[i]>>b[i];
for(i=0; i<n; i++)
{
c=1;
for(j=0; j<n; j++)
{
if(abs(a[i]-a[j])+abs(b[i]-b[j])>k)
{
c=0;
break;
}
}
if(c)
break;
}
if(c)
cout<<1<<endl;
else
cout<<-1<<endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n,k;
cin>>n>>k;
pair<int, int> l[n];
for (int i=0; i<n; i++){
int x,y;
cin>>x>>y;
l[i]=make_pair(x,y);
}
int ans=-1;
for (int i=0; i<n; i++){
bool pode=true;
for (int j=0; j<n; j++){
if (abs(l[i].first-l[j].first)+abs(l[i].second-l[j].second)>k) pode=false;
}
if (pode) ans=1;
}
cout<<ans<<endl;
}
}
| 8 | CPP |
import io
import os
from collections import Counter, defaultdict, deque
def solve(N, K, balls):
for x1, y1 in balls:
bad = False
for x2, y2 in balls:
if x1 == x2 and y1 == y2:
continue
if abs(x1 - x2) + abs(y1 - y2) > K:
bad = True
break
if not bad:
return 1
return -1
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
N, K = [int(x) for x in input().split()]
balls = [[int(x) for x in input().split()] for i in range(N)]
ans = solve(N, K, balls)
print(ans)
| 8 | PYTHON3 |
import math
i1=int(input())
for z in range(i1):
i = [int(a) for a in input().split()]
t=[]
a1=0
for x in range(i[0]):
t1= [int(a) for a in input().split()]
t.append(t1)
for x in t:
s=0
for z in t:
if math.fabs(x[0]-z[0])+math.fabs(x[1]-z[1])>i[1]:
s=1
if s==1:
break
if s==0:
a1=1
print(1)
break
if a1==0:
print(-1)
| 8 | PYTHON3 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# ballsofsteel.py
#
# Copyright 2020 grant <grant@DESKTOP-EBFFL3R>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
#
#
def main(args):
t = int(input());
p = [];
ks = [];
for i in range(t):
p.append([]);
ks.append(input().split(' '));
n = int(ks[i][0]);
for j in range(n):
p[i].append([]);
l = input().split(' ');
p[i][j].append(int(l[0]));
p[i][j].append(int(l[1]));
for i in range(t):
n = int(ks[i][0]);
k = int(ks[i][1]);
for j in range(n):
counter = 0;
for m in range(n):
if cityblock(p[i][j], p[i][m]) <= k:
counter = counter + 1;
if counter == n:
print(1);
break;
if counter != n:
print(-1);
def cityblock(p1, p2):
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]);
if __name__ == '__main__':
import sys
sys.exit(main(sys.argv))
| 8 | PYTHON3 |
R=lambda:[*map(int,input().split())]
exec(R()[0]*'n,k=R();a=[R()for _ in[0]*n];print(+(min(max(abs(x-u)+abs(y-v)for x,y in a)for u,v in a)<=k)or-1);') | 8 | PYTHON3 |
def check(ar,k):
for i in range(len(ar)):
c=0
x=ar[i][0]
y=ar[i][1]
for j in range(len(ar)):
xx=ar[j][0]
yy=ar[j][1]
if abs(xx-x) + abs(yy-y)<=k:
c+=1
else:
break
if c==len(ar):
return 1
return -1
y122=int(input())
for _ in range(y122):
n,k=map(int,input().split())
ar=[]
xl='xxx'
xr='xxx'
yl='xxx'
yr='xxx'
for i in range(n):
ar.append(list(map(int,input().split())))
print(check(ar,k))
| 8 | PYTHON3 |
def dist(x, y):
return sum(abs(x[i] - y[i]) for i in range(2))
t = int(input())
for __ in range(t):
n, k = map(int, input().split())
ls = []
for __ in range(n):
ls.append(tuple(map(int, input().split())))
ok = False
for i in range(n):
flag = False
for j in range(n):
if dist(ls[i], ls[j]) > k:
flag = True
break
if not flag:
ok = True
break
print(1 if ok else -1)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args&&... args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#define pi 3.141592653589
#define MOD 1000000007
#define to() int tt; cin>>tt; while(tt--)
#define pb push_back
#define in insert
#define mp make_pair
#define ff first
#define ss second
#define si(s) s.size()
#define fori(it,v) for(it=v.begin();it!=v.end(); it++)
#define for1(i,low,high) for(int i=low;i<high;i++)
#define for2(i,low,high) for(int i=low;i<=high;i++)
#define rev(i,high,low) for(int i=high;i>=low ;i--)
#define all(x) x.begin(), x.end()
#define fil(x,i) memset(x,i,sizeof(x));
#define setbits(x) __builtin_popcount(x)
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define read freopen("input.txt","r",stdin)
#define write freopen("output.txt","w",stdout)
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
void i_o() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin) ;
freopen("output.txt", "w", stdout) ;
#endif
}
int main()
{
boost; i_o();
to(){
int n,k; cin>>n>>k;
vector<pair<int,int> >v(n);
for1(i,0,n) cin>>v[i].ff>>v[i].ss;
bool ans=false;
for(int i=0;i<n;i++){
bool f=true;
for(int j=0;j<n;j++){
int d=abs(v[i].ff-v[j].ff)+abs(v[i].ss-v[j].ss);
if(d>k){
f=false; break;
}
}
if(f){
ans=true;
break;
}
}
if(ans)cout<<"1"<<endl;
else cout<<"-1"<<endl;
}
return 0;
}
| 8 | CPP |
import sys
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_list(): return list(map(int, sys.stdin.readline().strip().split()))
def get_list_string(): return list(map(str, sys.stdin.readline().strip().split()))
def get_string(): return sys.stdin.readline().strip()
def get_int(): return int(sys.stdin.readline().strip())
def get_print_int(x): sys.stdout.write(str(x) + '\n')
def get_print(x): sys.stdout.write(x + '\n')
from sys import maxsize
def solve():
for _ in range(get_int()):
n,k = get_ints()
data = []
for i in range(n):
data.append(get_list())
ans = -1
for i in range(n):
count = 0
for j in range(n):
if(i != j):
if(abs(data[i][0] - data[j][0]) + abs(data[i][1] - data[j][1]) <= k):
count += 1
if(count == n-1):
ans = 1
break
get_print_int(ans)
solve() | 8 | PYTHON3 |
#include<iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<utility>
#include<vector>
#include<algorithm>
#include<cmath>
#include<iomanip>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
ii ar[100];
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;
for(int i = 1; i <= n; ++i){
cin >> ar[i].fi >> ar[i].se;
}
for(int i = 1; i <= n; ++i){
bool cek = true;
for(int j = 1; j <= n; ++j){
int dist = abs(ar[i].fi - ar[j].fi) + abs(ar[i].se - ar[j].se);
if(dist > k)cek = false;
}
if(cek){
cout << 1 << endl;
break;
}
if(i == n)cout << -1 << 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;
vector< pair<int, int> > a(n);
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
int flag = -1;
for (int i = 0; i < n; i++) {
bool cont = 0;
for (int j = 0; j < n; j++) {
int x = abs(a[j].first - a[i].first) + abs(a[j].second - a[i].second);
if (x > k) {
cont = 1;
break;
}
}
if (!cont) {
flag = 1;
break;
}
}
cout << flag << '\n';
}
} | 8 | CPP |
#include <bits/stdc++.h>
#include <cmath>
#define floop(b) for(long long i=0;i<b;i++)
#define test long long t_c;cin>>t_c;for(long long ks=1;ks<=t_c;ks++)
#define pb push_back
#define sc(a) scanf("%lld",&a)
#define vi vector<int>
#define all(x) x.begin(),x.end()
#define cy cout<<"YES\n";
#define cn cout<<"NO\n";
#define nl cout<<endl;
typedef long long ll;
typedef long long int lli;
using namespace std;
int main()
{
ios::sync_with_stdio(0);
test
{
int n,k;
cin>>n>>k;
int x[n+1],y[n+2];
floop(n)
{
cin>>x[i]>>y[i];
}
int f=0,c=0;
for(int i=0;i<n;i++)
{
f=0;
for(int j=0;j<n;j++)
{
int d=abs(x[i]-x[j])+abs(y[i]-y[j]);
if(d<=k)
{
f++;
//close[i][j]=1;
}
else
{
break;
}
}
// cout<<"i="<<i<<" "<<f<<endl;
if(f==n)
{
c=1;
break;
}
}
if(c==1)
{
cout<<1<<endl;
}
else
{
cout<<-1<<endl;
}
}
}
| 8 | CPP |
from collections import deque
sol = []
for test in range(int(input())):
n, k = map(int, input().split())
points = []
for i in range(n):
points.append(tuple(map(int, input().split())))
invalid=True
for i in range(n):
can=True
for j in range(n):
if i == j: continue
dist = abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1])
if dist>k:
can=False
break
if can:
invalid=False
break
if invalid:
sol.append(-1)
else:
sol.append(1)
for r in sol:
print(r)
| 8 | PYTHON3 |
from sys import stdin
"""
n=int(stdin.readline().strip())
n,m=map(int,stdin.readline().strip().split())
s=list(map(int,stdin.readline().strip().split()))
s=stdin.readline().strip()
"""
cas=int(stdin.readline().strip())
for ca in range(cas):
n,k=map(int,stdin.readline().strip().split())
s=[list(map(int,stdin.readline().strip().split())) for i in range(n)]
f1=True
for i in range(n):
f=True
for j in range(n):
if abs(s[i][0]-s[j][0])+abs(s[i][1]-s[j][1])>k:
f=False
break
if f:
print(1)
f1=False
break
if f1:
print(-1)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int mod = 998244353;
int main() {
int T; cin >> T;
for(int l=0; l<T; l++) {
int n, k; cin >> n >> k;
vector<pair<int, int>> vec(n);
for(int i=0; i<n; i++) {
cin >> vec[i].first >> vec[i].second;
}
int dis = 1e9;
for(int i=0; i<n; i++) {
int maxd = 0;
for(int j=0; j<n; j++) {
if (i == j) continue;
maxd = max(maxd, abs(vec[i].first - vec[j].first) + abs(vec[i].second - vec[j].second));
}
dis = min(maxd, dis);
}
if (dis <= k) cout << 1 << endl;
else cout << -1 << endl;
}
} | 8 | CPP |
# def gcd(a,b):
# if (b==0):
# return a
# else:
# return gcd(b,a%b)
# n = int(input())
# for i in range(n):
# x = int(input())
# c = []
# for i in range(2,4*x+1):
# a = i+1
# b = i
# if a%b!=0 and b%a!=0 or gcd(a,b)!=1:
# c.append(a)
# c.append(b)
#
# c = set(c)
# c2 = c
# # print(c)
# p = 0
# for l in c:
# for k in c2:
# if p<x:
# if l%k!=0:
# p+=1
# print(k, end=" ")
# else:
# break
# print()
#
#
# #
# # for i in range(int(input())):
# # a, b = list(map(int, input().split()))
# # s = input()
# # s.count()
# n = int(input())
# for i in range(n):
# x = int(input())
# s = input()
# print(*sorted(s),sep="")
# t = int(input())
# # for i in range(t):
# # n, k = list(map(int, input().split()))
# # x = []
# # y = []
# # for j in range(n):
# # p = list(map(int, input().split()))
# # x.append(p[0])
# # y.append(p[1])
# #
# # s = []
# # c = 0
# # for i in range(n):
# # for j in range(i + 1, n):
# # s.append(abs(x[i] - x[j]) + abs(y[i] - y[j]))
# #
# # print(s)
# # if max(s)<=k:
# # print(1)
# # else:
# # print(-1)
t = int(input())
for i in range(t):
n, k = list(map(int, input().split()))
x = []
y = []
for j in range(n):
p = list(map(int, input().split()))
x.append(p[0])
y.append(p[1])
ll = len(x)
c = 0
f = 0
for i in range(ll):
c = 0
for j in range(ll):
if j == i:
continue
else:
s = abs(x[i] - x[j]) + abs(y[i] - y[j])
if s <= k:
c += 1
else:
break
if c==n-1 and f == 0:
f = 1
print(1)
if f == 0:
print(-1)
| 8 | PYTHON3 |
import math
for _ in range(int(input())):
n,k=map(int,input().split())
l=[]
for __ in range(n):
x,y=map(int,input().split())
l.append([x,y])
c=0
cc=0
#print(l,len(l),n)
for i in range(n):
c=0
for j in range(n):
if i!=j and ((abs(l[i][0]-l[j][0])+abs(l[i][1]-l[j][1])))<=k:
c+=1
#print(i,j,((abs(l[i][0]-l[j][0])**2+abs(l[i][1]-l[j][1])**2)),k)
if c==n-1:
print(1)
cc=1
break
if cc!=1:
print(-1)
| 8 | PYTHON3 |
t=int(input())
for t1 in range(t):
n,k=map(int,input().split())
x=[]
y=[]
for t2 in range(n):
x1,x2=map(int,input().split())
x.append(x1)
y.append(x2)
flag=0
for a in range(n):
flag=0
for b in range(n):
if a!=b:
if abs(x[a]-x[b])+abs(y[a]-y[b])>k:
flag=1
if flag==0:
print(1)
flag=2
break
if flag!=2:
print(-1)
| 8 | PYTHON3 |
# ------------------- fast io --------------------
import os
import sys
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")
# ------------------- fast io --------------------
from math import ceil,floor,sqrt
from collections import Counter,defaultdict,deque
def int1():
return int(input())
def map1():
return map(int,input().split())
def list1():
return list(map(int,input().split()))
mod=pow(10,9)+7
def solve():
n,k=map1()
l1=[]
d=defaultdict(list)
for i in range(n):
l1.append(list1())
for i in range(n):
c=0
for j in range(n):
if(i!=j):
v=abs(l1[i][0]-l1[j][0])+abs(l1[i][1]-l1[j][1])
if(v<=k):
c=c+1
else:
c=0
if(c==(n-1)):
print(1)
return
print(-1)
for _ in range(int(input())):
solve()
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ii pair<ll,ll>
#define x first
#define y second
const ll M=1e6+7;
ii a[M];
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
ll m;
cin>>m;
for(ll i=1;i<=n;i++)
{
cin>>a[i].x>>a[i].y;
}
bool check1=false;
for(ll i=1;i<=n;i++)
{
ll kq=0;
for(ll j=1;j<=n;j++)
{
kq=max(kq,abs(a[i].x-a[j].x)+abs(a[i].y-a[j].y));
}
if(kq<=m)
{
check1=true;
}
}
if(!check1)
{
cout<<-1;
}
else
{
cout<<1;
}
cout<<endl;
}
}
| 8 | CPP |
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
# input = sys.stdin.readline
t = int(input())
while t:
t -= 1
n, k = list(map(int, input().split()))
points = []
for _ in range(n):
points.append(list(map(int, input().split())))
for point in points:
ans = 1
for opoint in points:
if point != opoint and abs(point[0]-opoint[0]) + abs(point[1]-opoint[1]) > k:
ans = -1
if ans == 1:
print(1)
break
else:
print(-1) | 8 | PYTHON3 |
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
#define ll long long int
#define ff first
#define ss second
#define mkp make_pair
#define pb push_back
#define pf push_front
#define maxn 1000001
#define mod 1000000007
using namespace std;
void solve(){
int n,k;
cin>>n>>k;
vector<pair<int,int>>v(n);
for(int i=0;i<n;++i){
cin>>v[i].ff>>v[i].ss;
}
// sort(v.begin(),v.end());
for(int i=0;i<n;++i){
bool flag=true;
bool flag1=true;
for(int j=i+1;j<n;++j){
if(abs(v[i].ff-v[j].ff)+abs(v[i].ss-v[j].ss)>k){
flag=false;
}
}
for(int j=0;j<i;++j){
if(abs(v[i].ff-v[j].ff)+abs(v[i].ss-v[j].ss)>k){
flag1=false;
}
}
if(flag&&flag1){
cout<<"1\n";
return;
}
}
cout<<"-1\n";
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t;
cin>>t;
while(t--){
solve();
}
return 0;
} | 8 | CPP |
#include <iostream>
#include <cmath>
constexpr int N = 105;
int T, n, k;
int x[N], y[N];
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cin >> T;
while (T--) {
std::cin >> n >> k;
for (int i = 1; i <= n; ++i) std::cin >> x[i] >> y[i];
bool flag = 0;
for (int i = 1; i <= n; ++i) {
bool ok = 1;
for (int j = 1; j <= n; ++j)
if (std::abs(x[i] - x[j]) + std::abs(y[i] - y[j]) > k) {
ok = 0;
break;
}
if (ok) { flag = 1; break; }
}
std::cout << (flag ? "1\n" : "-1\n");
}
return 0;
}
| 8 | CPP |
#include<bits/stdc++.h>
#define ll long long int
#define pb push_back
#define mod 1000000007
#define pi (3.141592653589)
using namespace std;
ll n,k;
bool compare(pair<ll,ll> a,pair<ll,ll> b)
{
if(a.first<b.first)
return a.first<b.first;
else
return a.second<b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout.precision(10);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int T;
cin >> T;
while(T--)
{
cin>>n>>k;
pair<ll,ll> p[n];
for(int i=0;i<n;i++)
cin>>p[i].first>>p[i].second;
ll total=0;
bool f=0;
for(int i=0;i<n;i++)
{
total=0;
for(int j=0;j<n;j++)
{
ll dis = abs(p[i].first-p[j].first)+abs(p[i].second-p[j].second);
if(dis<=k)
total++;
}
if(total==n)
{
f=1;break;
}
}
if(f)
cout<<1<<"\n";
else
cout<<-1<<"\n";
}
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n,k=[int(x) for x in input().split(' ')]
points=[]
for i in range(n):
point=[int(x) for x in input().split(' ')]
points.append(point)
flm=0
for i in range(len(points)):
fl=1
for j in range(len(points)):
if((abs(points[i][0]-points[j][0])+abs(points[i][1]-points[j][1]))>k):
fl=0
break
if(fl):
flm=1
break
if(flm):
print(1)
else:
print(-1)
| 8 | PYTHON3 |
import sys, os
# import numpy as np
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
from itertools import permutations
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))
# read_f = lambda file: list(map(int, file.readline().strip().split()))
# from time import time
# sys.setrecursionlimit(5*10**6)
MOD = 10**9 + 7
def f(a, b, x, y, k):
return((abs(x-a)+abs(y-b)) <= k)
def main():
# file1 = open("C:\\Users\\shank\\Desktop\\Comp_Code\\input.txt", "r")
# n = int(file1.readline().strip());
# arr = list(map(int, file1.read().strip().split(" ")))
# file1.close()
# n = int(input())
ans = []
for _ in range(int(input())):
n, k =read(); arr = []
for i in range(n):arr.append(read())
# arr.sort()
# a, b =arr[0]; x, y = arr[-1]
# flag = 1
for i in arr:
a, b = i
fl = 1
for j in arr:
x, y = j
fl &= f(a, b, x, y, k)
if fl:
ans.append(1)
break
if not fl:
ans.append(-1)
print(("\n").join(map(str, ans)))
# file = open("output.txt", "w")
# file.write(ans+"\n")
# file.close()
if __name__ == "__main__":
main()
"""
trygubbugyrt
""" | 8 | PYTHON3 |
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<utility>
#include<list>
#include<queue>
#include<set>
#include<cmath>
#include<map>
#include<bitset>
using namespace std;
#define int long long
#define nl <<"\n"
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<char> vc;
typedef pair<int, int> pi;
typedef vector<pair<int, int> > vpi;
template<typename T> ostream& operator<<(ostream& stream, vector<T>& v)
{
for (T& x : v) stream << x << " "; return stream;
}
template<typename T> istream& operator>>(istream& stream, vector<T>& v)
{
for (T& x : v) stream >> x; return stream;
}
template<typename T> void sort(vector<T>& v)
{
std::sort(v.begin(), v.end());
return;
}
template<typename T> T max(vector<T>& v)
{
return *(max_element(v.begin(), v.end()));
}
template<typename T> T min(vector<T>& v)
{
return *(min_element(v.begin(), v.end()));
}
void solve()
{
int n,k;
cin>>n>>k;
vpi a(n);
for (size_t i = 0; i < n; i++)
{
int x,y;
cin>>x>>y;
a[i]={x,y};
}
for (size_t i = 0; i < n; i++)
{
int count=1;
for (size_t j = 0; j < n; j++)
{
if(abs(a[i].first-a[j].first)+abs(a[j].second-a[i].second)>k)
{
count=0;
continue;
}
}
if(count)
{
cout<< 1 nl;
return;
}
}
cout<<-1 nl;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--)
{
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#define pi 126262
using namespace std;
const int maxx=1e6+7;
typedef long long ll;
int T,n,k,x[110], y[110];
int check(int id)
{
int ans=0;
for(int i = 0; i < n; i++)
{
int dis = abs(x[id] - x[i]) + abs(y[id] - y[i]);
ans = max(ans, dis);
}
return ans;
}
int main()
{
cin >> T;
while(T--)
{
cin >> n >> k;
for (int i = 0; i < n;i++)
cin >> x[i] >> y[i];
int ans = -1;
for (int i = 0; i < n; i++)
{
if (check(i) <= k) { ans = 1; goto nex;}
}
nex:
printf("%d\n",ans);
}
return 0;
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n,k;
struct stu
{
int a,b;
}i[105];
int main()
{
int t;
cin>>t;
while(t--)
{
cin>>n>>k;
for(int x=0;x<n;x++)
{
cin>>i[x].a>>i[x].b;
}
bool flag=false;
for(int x=0;x<n;x++)
{
int y=0;
for(;y<n;)
{
if(x==y)
{
y++;
continue;
}
if(abs(i[x].a-i[y].a)+abs(i[x].b-i[y].b)>k)
{
break;
}
y++;
}
if(y==n)
{
flag=true;
}
}
if(flag)cout<<"1"<<endl;
else cout<<"-1"<<endl;
}
}
| 8 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.