input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# -*- coding: utf-8 -*-
def main():
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
reverse_v = v[::-1]
ans = 0
for left in range(k + 1):
for right in range(k - left + 1):
if left + right > n:
continue
remai... | # -*- coding: utf-8 -*-
def main():
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
reverse_v = v[::-1]
ans = 0
# See:
# https://www.youtube.com/watch?v=m-Nov1EvGoc
for left in range(k + 1):
for right in range(k - left + 1):
if l... | p03032 |
from collections import deque
from copy import deepcopy
import heapq
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
v_sorted = sorted(v)
ans = 0
for i in range(k+1):
if True:
for nl in range(i+1):
nr = min(k - nl, n-nl)
ansl, ansr = 0, 0
... | from collections import deque
from copy import deepcopy
import heapq
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
v_sorted = sorted(v)
ans = 0
for i in range(k+1):
for nl in range(i+1):
nr = min(k - nl, n-nl)
ansl, ansr = 0, 0
for n_trash in range... | p03032 |
from collections import deque
from copy import deepcopy
import heapq
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
v_sorted = sorted(v)
ans = 0
for i in range(k+1):
for nl in range(i+1):
nr = min(k - nl, n-nl)
ansl, ansr = 0, 0
for n_trash in range... | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for lr in range(min(n, k)+1):
for l in range(lr+1):
r = lr - l
jewels = v[:l]+v[-r:] if r > 0 else v[:l]
n_release = k - lr
ans_cur = 0
for j in sorted(jewels):
if j < 0... | p03032 |
from collections import deque
N, K = [int(s) for s in input().split()]
V = [int(s) for s in input().split()]
que = deque([(0, [], V, 0, True, True)]) # total, negative items, deque, count, left_flag, right_flag
best = 0
while que:
t, s, v, n, lf, rf = que.pop()
if n >= K:
best = max([best, ... | from collections import deque
N, K = [int(s) for s in input().split()]
V = [int(s) for s in input().split()]
best = 0
for a in range(min([K, N]) + 1):
for b in range(min([K, N]) - a + 1):
L = V[:a] + V[N - b:]
Lp = [i for i in L if i >= 0]
Lm = [i for i in L if i < 0]
Lm... | p03032 |
import sys
n, k, *v = list(map(int, sys.stdin.read().split()))
def main():
m = min(n, k)
res = 0
for i in range(m+1):
for j in range((m-i)+1):
l = v[:i]
r = v[-j:] if j > 0 else []
take = l + r
s = sum(take)
neg = [t for t in... | import sys
n, k, *v = list(map(int, sys.stdin.read().split()))
def main():
m = min(n, k)
ls = [None] * (m + 1)
rs = [None] * (m + 1)
l_neg = [None] * (m + 1)
r_neg = [None] * (m + 1)
ls[0] = 0
rs[0] = 0
l_neg[0] = []
r_neg[0] = []
for i in range(m):
... | p03032 |
from heapq import heappop, heappush
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for left in range(min(N, K) + 1):
for right in range(min(N, K) - left + 1):
heap = []
for v in V[:left]:
heappush(heap, v)
for v in V[N - right:... | N, K = list(map(int, input().strip().split()))
V = list(map(int, input().strip().split()))
maxi = 0
for i in range(min(N, K)):
for o in range(i+2):
hand = []
for p in range(o):
hand.append(V[p])
for p in range(N-(i-o)-1, N):
hand.append(V[p])
hand.... | p03032 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,K,*V = list(map(int,read().split())) #*Vで行単位の配列を得られる。
#print(V)
vals = [] #valuesの略。
for L in range(N+1): #左
for R in range(N+1): #右
if L+R > N: #このbreakで、うまく左右からとれる。
... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
answer = 0
for i in range(min(N + 1, K + 1)):
for j in range(i + 1):
left = j
right = i - j
q = []
for k in range(left):
q.append(V[k])
for k in range(N - right, N):
q.append(V[k])
q.sort... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
opt = ['pol', 'por', 'pul', 'pur']
res = []
def helper(res, Q, M, K):
if K==0:
res.append(sum(M))
else:
if len(Q) > 0:
# pol
helper(res, Q[1:], M+[Q[0]], K-1)
# por
helper(res, Q[:-1], M+[Q[-1]], K... | a,k=list(map(int,input().split()))
L=list(map(int,input().split()))
ans=0
for i in range(min(k,a)+1):
for j in range(min(k,a)-i+1):
S=[0]+L[:i]+L[a-j:]
S.sort()
x=0
while x < k-(j+i):
if S[x]>=0:
break
x+=1
ans=max(ans,sum(S)-sum(S[:x]))
print(ans) | p03032 |
def main():
N, K = (int(i) for i in input().split())
V = [int(i) for i in input().split()]
if 2*N <= K:
ans = sum(v for v in V if v > 0)
return print(ans)
ans = 0
R = min(N, K)
for a in range(R+1):
for b in range(R+1):
if R < a+b:
co... | def main():
N, K = (int(i) for i in input().split())
V = [int(i) for i in input().split()]
if 2*N <= K:
ans = sum(v for v in V if v > 0)
return print(ans)
ans = 0
for a in range(N+1):
for b in range(N+1):
if N < a+b:
continue
... | p03032 |
import heapq
import copy
N, K = list(map(int, input().split()))
*V, = list(map(int, input().split()))
M = min(N, K)
ans = 0
a = 0
ah = []
for i in range(M + 1):
if i > 0:
v = V[i - 1]
a += v
if v < 0:
heapq.heappush(ah, v)
b = a
bh = copy.copy(ah)
... | import heapq
import copy
N, K = list(map(int, input().split()))
*V, = list(map(int, input().split()))
M = min(N, K)
ans = 0
for i in range(M + 1):
for j in range(M - i + 1):
l = V[:i] + V[N - 1:N - j - 1:-1]
t = sum(l)
l.sort()
for n in range(min(K - i - j, len(l))):... | p03032 |
N,K = list(map(int, input().split()))
V = list(map(int, input().split()))
from collections import deque
d=deque(V)
my_gem = []
max_value=-1000000000
def nxt(num,cur_v):
global max_value
global my_gem
if num == K :
return
if len(d) > 0:
# so... | N,K = list(map(int, input().split()))
V = list(map(int, input().split()))
import sys
max_value=-1000000000
for i in range(K+1):
for left in range(i+1):
right= i - left
leftlist = V[:left]
if right == 0:
rightlist = []
... | p03032 |
import copy
import bisect
from collections import deque
def dfs(i, k, v, x):
if i >= k:
return sum(x)
y = [0, 0, 0, 0]
if len(v) > 0:
p = v.popleft()
xi = copy.copy(x)
bisect.insort(xi, p)
y[0] = dfs(i + 1, k, v, xi)
v.appendleft(p)
if len(v... | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
if n == 1:
ans = max(0, v[0])
else:
ans = 0 if k < n else sum(v)
for i in range(min(k + 1, n)):
for j in range(i + 1):
t = v[:j]
if j != i:
t += v[j - i:]
... | p03032 |
from heapq import*
n,k=list(map(int,input().split()))
*v,=list(map(int,input().split()))
motimono=[]
ans=[]
if k>=n:
k-=n
heapify(v)
ans.append(sum(v))
for i in range(k):
if len(v)>0:
heappop(v)
ans.append(sum(v))
print((max(ans)))
else:
v*=2
for j... | n,k=list(map(int,input().split()))
*v,=list(map(int,input().split()))
motimono=[]
ans=[]
if k>=n:
k-=n
ans.append(sum(v))
v.sort()
for i in range(min(k,len(v))):
v[i]=0
ans.append(sum(v))
print((max(ans)))
else:
v*=2
for j in range(1,k+1):
for i in rang... | p03032 |
from heapq import*
n,k=list(map(int,input().split()))
*v,=list(map(int,input().split()))
motimono=[]
ans=[]
v*=2
for j in range(1,min(n,k)+1):
for i in range(n-j,n+1):
motimono=v[i:i+j]
ans.append(sum(motimono))
heapify(motimono)
for i in range(k-j):
if len(mo... | n,k,*v=list(map(int,open(0).read().split()))
motimono=[]
ans=[]
v*=2
for j in range(1,min(n,k)+1):
for i in range(n-j,n+1):
motimono=v[i:i+j]
ans.append(sum(motimono))
motimono.sort()
for i in range(k-j):
if len(motimono)>0:
del motimono[0]
... | p03032 |
n,k,*v=list(map(int,open(0).read().split()))
motimono=[]
ans=[]
v*=2
for j in range(1,min(n,k)+1):
for i in range(n-j,n+1):
motimono=v[i:i+j]
ans.append(sum(motimono))
motimono.sort()
for i in range(k-j):
if len(motimono)>0:
del motimono[0]
... | n,k,*v=list(map(int,open(0).read().split()))
motimono=[]
ans=[]
v*=2
for j in range(1,min(n,k)+1):
for i in range(n-j,n+1):
motimono=v[i:i+j]
ans.append(sum(motimono))
motimono.sort()
for i in range(min(k-j,j)):
del motimono[0]
ans.append(sum(motimo... | p03032 |
from collections import deque
n, k = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for t in range(k//2 + 1):
hand = deque(V[:k-t])
rest = deque(V[k-t:])
cur_sum = sum(hand)
for j in range(k-t+1):
put_back = 0
rev_hand = sorted(hand)
... | n, k = list(map(int, input().split()))
V = list(map(int, input().split()))
def get_jewelries(box, left_pop, right_pop):
if left_pop + right_pop >= len(box):
return box[:]
left = box[:left_pop]
right = box[-right_pop:] if right_pop else []
return left + right
candidates = []
... | p03032 |
N , K = list(map(int,input().split()))
D = list(map(int,input().split()))
maxValue = 0
actList = [0]*K
for i in range(4**K):
act = i
valList = []
V = D.copy()
for j in range(K):
actList[j] = (act % 4)
act = int(act / 4)
for j in actList:
if(j == 0): # 操作 A... | N , K = list(map(int,input().split()))
D = list(map(int,input().split()))
maxValue = 0
for i in range(min(N,K)+1):
for j in range(min(N,K)-i+1):
left = D[:i]
right = D[N-j:]
merge = (left + right + [0])
merge.sort()
index = 0
for k in range(K-i-j):
... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for left in range(K + 1):
for right in range(K + 1):
if left > N - right or left + right > K:
continue
G = V[:left] + V[N - right:]
G.sort()
dis = 0
for i, g in enumer... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for left in range(K + 1):
for right in range(K + 1):
if left + right > K or left + right > N:
break
diff = K - left - right
takes = V[:left] + V[N - right:]
takes.sort(reverse=... | p03032 |
def main():
import sys
import heapq
from copy import deepcopy
from collections import deque
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
_N, K = [int(x) for x in input().strip().split()]
V = deque([int(x) for x in input().strip().split()])
max_ans = sum([v for v... | def main():
import sys
import heapq
from copy import deepcopy
from collections import deque
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N, K = [int(x) for x in input().strip().split()]
V = [int(x) for x in input().strip().split()]
ans = -float('inf')
for l... | p03032 |
from collections import deque
import heapq
import copy
n, k = list(map(int, input().split()))
v = deque(list(map(int, input().split())))
j = []
heapq.heapify(j)
def solve(hep, jue, c, end=k):
if c==k:
return sum(hep)
result = [0]
if len(jue)!=0:
x, y = copy.deepcopy(hep), cop... | import heapq
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
result = []
for i in range(min(n, k)+1):
for j in range(min(n, k)+1-i):
x = v[:i]+v[n-j:]
c = k - (i + j)
x.sort()
for t in range(min(len(x), c)):
if x[0]<0:
... | p03032 |
from copy import deepcopy
from collections import deque
from functools import partial, lru_cache
from heapq import heappush, heappop
inputs = open(0).readlines()
n, k = list(map(int, inputs[0].split()))
V = deque(list(map(int, inputs[1].split())))
W = []
def dfs(root, option, function):
stack =[root]
... | from collections import deque
inputs = open(0).readlines()
n, k = list(map(int, inputs[0].split()))
V = deque(list(map(int, inputs[1].split())))
def calc(ii, jj, kk):
W = []
for i in range(ii):
W.append(V[i])
for j in range(jj):
W.append(V[-j-1])
W.sort(reverse=True)
for... | p03032 |
from collections import deque
inputs = open(0).readlines()
n, k = list(map(int, inputs[0].split()))
V = deque(list(map(int, inputs[1].split())))
def calc(ii, jj, kk):
W = []
for i in range(ii):
W.append(V[i])
for j in range(jj):
W.append(V[-j-1])
W.sort(reverse=True)
for... | n, k, *V = list(map(int, open(0).read().split()))
def calc(i, j, k):
W = sorted(V[:i] + V[:-j-1:-1], reverse=True)
for _ in range(k):
if W[-1] < 0:
W.pop()
return sum(W)
ans = 0
r = min(n, k)+1
for i in range(r):
for j in range(r-i):
for k_ in range(min(i+j, k+1-... | p03032 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | p03032 |
import sys
input = sys.stdin.readline
from collections import deque
def main():
n, k = list(map(int, input().strip().split()))
v = deque(list(map(int, input().strip().split())))
ans = 0
for i in range(k+1):
for j in range(k - i + 1):
now = 0
s = []
if i + j > n:
continue
md = k - i ... | import sys
input = sys.stdin.readline
def main():
n, k = list(map(int, input().strip().split()))
v = list(map(int, input().strip().split()))
ans = 0
for a in range(k+1):
for b in range(k-a+1):
if a + b > n:
continue
t = sorted(v[:a] + v[n-b:])
for i in range(k-a-b):
if i < len(t) an... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
s = [(K, V[:], [], False)]
while s:
cnt, v, bag, flag = s.pop()
ans = max(ans, sum(bag))
if cnt > 0 and v and not flag:
s.append((cnt-1, v[1:], bag + [v[0]], False))
s.append((cnt-1, v[:-1], bag + [... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for l in range(K+1):
for r in range(K-l+1):
if l + r < N:
bag = V[:l] + V[N-r:] + [0]
rest_ope = K-l-r
else:
bag = V[:]
rest_ope = K - N
for _ in ra... | p03032 |
from collections import deque, _heapq
N, K = list(map(int, input().split()))
V = deque(list(map(int, input().split())))
class Money:
def __init__(self):
self.yen = 0
self.red = []
def value(self):
return self.yen + sum(self.red)
def add(self, yen):
if yen >= 0... | from collections import deque, _heapq
N, K = list(map(int, input().split()))
V = deque(list(map(int, input().split())))
class Money:
def __init__(self):
self.yen = 0
self.red = []
def value(self):
return self.yen + sum(self.red)
def add(self, yen):
if yen >= 0... | p03032 |
from collections import deque
import copy
N,K = list(map(int,input().split(" ")))
V = deque(list(map(int,input().split(" "))))
def search(N,K,V,score,a,b):
if a+b < min(N,K):
Vb = copy.copy(V)
scoreA = copy.copy(score)
scoreB=copy.copy(score)
scoreA.append(V.popleft())... | from collections import deque
N,K = list(map(int,input().split(" ")))
V = deque(list(map(int,input().split(" "))))
def search(N,K,V,score):
ans = 0
for i in range(min(N,K)+1):
for j in range(min(N,K)-i+1):
score = []
for a in range(i):#do operation A
... | p03032 |
#!/usr/bin/env python3
import sys
from collections import deque
def solve(N: int, K: int, V: "List[int]"):
mani = []
for ac in range(K+1):
for bc in range(K+1):
for cc in range(K+1):
for dc in range(K+1):
if (ac+bc+cc+dc) == K:
... | #!/usr/bin/env python3
import sys
from collections import deque
def solve(N: int, K: int, V: "List[int]"):
mani = []
for ac in range(K+1):
for bc in range(K+1):
for cc in range(K+1):
if (ac+bc+cc) == K:
mani.append([ac,bc,cc])
max_v = 0... | p03032 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
# rstrip().decode('utf-8')
# INF=float("inf")
#MOD=10**9+7
# sys.setrecursionlimit(2147483647)
# import math
#import numpy as np
# import operator
# import bisect
# from heapq import heapify,h... | import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(eval(input()))
def FI(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input... | p03032 |
import copy,heapq
N,K=list(map(int,input().split()))
V=list(map(int,input().split()))
ans=0
left=copy.copy(V)
for i in range(1,N):
left[i]+=left[i-1]
right=copy.copy(V)
for i in range(1,N):
right[-i-1]+=right[-i]
for i in range(0,N+1):
for j in range(0,N-i+1):
dispose=K-i-j
... | import random
N,K=list(map(int,input().split()))
V=list(map(int,input().split()))
if K==0:
print((0))
exit()
if 0:
V=[random.randint(-10**7,10**7) for i in range(N)]
ans=-float("inf")
for i in range(N+1):
for j in range(N-i+1):
if i+j>K:
continue
tmp=[V... | p03032 |
import bisect
abcd = []
n, k = list(map(int, input().split()))
v_list = list(map(int, input().split()))
for a in range(0, k+1):
for b in range(0, k+1-a):
for c in range(0, k+1-a-b):
d = k-a-b-c
abcd.append([a,b,c,d])
ans = 0
for curr_abcd in abcd:
a,b,c,d = c... | from bisect import bisect_left, bisect_right
n,k = list(map(int, input().split()))
vl = list(map(int, input().split()))
ans = 0
for get_num in range(0,k+1):
rem = k-get_num
for l in range(0,get_num+1):
r = get_num-l
if l+r > n: continue
ls = vl[:l]
rs = vl[n-r:]
... | p03032 |
from bisect import bisect_left, bisect_right
n,k = list(map(int, input().split()))
vl = list(map(int, input().split()))
ans = 0
for get_num in range(0,k+1):
rem = k-get_num
for l in range(0,get_num+1):
r = get_num-l
if l+r > n: continue
ls = vl[:l]
rs = vl[n-r:]
... | n,k = list(map(int, input().split()))
vl = list(map(int, input().split()))
ans = 0
ab_max = min(n,k)
for l in range(ab_max+1):
for r in range(ab_max+1):
if l+r > k: continue
if l > n-r: continue
ls = vl[:l]
rs = vl[n-r:]
# print(ls,rs)
vals = ls + rs
... | p03032 |
#import heapq
import copy
N,K=list(map(int,input().split()))
V=list(map(int,input().split()))
V.append(0)#右から取る時用
S=[0]*(N+1)#累積和
for i in range(N):
S[i+1]=S[i]+V[i]
#左からi番目まで見たときに，持っている負の宝石
left=[[] for _ in range(N+1)]
for i in range(N):
left[i+1]=copy.deepcopy(left[i])
if V[i]<0:
... | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,K=MI()
V=LI()
ans=0
import heapq
#左からa個，右からb個とって，あまり分で負数を捨てる
for a ... | p03032 |
N,K = list(map(int, input().split()))
V = [int(v) for v in input().split()]
def f(L, i, n):
if i == 0 or len(L) == 0:
return 0
if L[n] >= 0:
t = L[n]
if n >= 0:
n += 1
else:
n -= 1
return t+f(L,i-1,n)
else:
t = L[n]
... | N,K = list(map(int, input().split()))
V = [int(v) for v in input().split()]
ans = 0
for i in range(K+1):
if i < N:
for j in range(i+1):
temp1 = V[:j]
temp2 = V[N-(i-j):]
temp = temp1 + temp2
temp.sort()
s = sum(temp)
k = 0
... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
def opA(D, v):
ret = True
if len(v) != 0:
D.append(v.pop(0))
else:
ret = False
return D, v, ret
def opB(D, v):
ret = True
if len(v) != 0:
D.append(v.pop(-1))
else:
ret = False
return D, v, ret
... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
R = min(N, K)
l = []
ans = 0
for a in range(R + 1):
for b in range(R + 1 - a):
l = V[:a] + V[N - b:]
l.sort()
for i in range(K - a - b + 1):
ans = max(ans, sum(l[i:]))
print((max(ans, 0))) | p03032 |
import itertools
import copy
class Deque:
def __init__(self, default_deque: list):
self.in_hand = []
self.deque = default_deque
def operation(self, operation_type: str):
if operation_type == "A":
self.in_hand.append(self.deque[0])
del self.deque[0]
... | import itertools
import copy
class Deque:
def __init__(self, default_deque: list, max_count: int):
self.in_hand = []
self.deque = default_deque
self.operation_count = 0
self.max_count = max_count
def operation(self, operation_type: str):
if operation_type =... | p03032 |
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = []
for i in range(1,K+1):
for j in range(2**i):
gem = 0
minus = []
flag = True
A = 0
B = -1
for k in range(i):
if (j >> k) & 1 == 1:
if A <= N-1:
... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = []
for i in range(1,min(K,N)+1):
for a in range(i+1):
b = i-a
AB = V[:a]
if b > 0:
AB += V[-b:]
AB.sort(reverse = True)
for j in range(K-i):
if AB and AB[-1] < 0:
... | p03032 |
from heapq import heapify, heappop
N, K = list(map(int, input().split()))
vl = list(map(int, input().split()))
vr = list(reversed(vl))
sum_L = [0]
for vv in vl:
sum_L.append(sum_L[-1] + vv)
sum_R = [0]
for vv in vr:
sum_R.append(sum_R[-1] + vv)
ans = 0
for pick in range(min(K, N) + 1):
for... | N, K = list(map(int, input().split(" ")))
v = list(map(int, input().split(" ")))
pick_max = min(N, K)
ans = 0
for left in range(pick_max + 1):
for right in range(pick_max - left + 1):
t = v[:left] + v[N - right:]
m = sorted([x for x in t if x < 0])[:K - left - right]
ans = max(ans,... | p03032 |
inf = float('inf')
N, K = list(map(int, input().split()))
v = list(map(int, input().split()))
volume = max(N, K)
take_max = min(N, K)
dpl = [[-inf] * (volume + 1) for _ in range(N + 1)]
dpr = [[-inf] * (volume + 1) for _ in range(N + 1)]
dpl[0][0] = dpr[0][0] = 0
for i, vv in enumerate(v, 1):
for t... | N, K = list(map(int, input().split()))
v = list(map(int, input().split()))
max_pick = min(K, N)
ans = 0
# 左右から取る量を決め打ち
for left in range(max_pick + 1):
for right in range(max_pick - left + 1):
t = v[:left] + v[N - right:]
m = sorted([x for x in t if x < 0])[:K - left - right]
... | p03032 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
m = min(n, k)
for i in range(m + 1):
for j in range(m - i + 1):
t = v[:i] + v[n - j:]
t.sort()
d = tuple([x for x in t if x < 0])[:k - i - j]
ans = max(ans, sum(t) - sum(d))
print(ans)
| def main():
N, K = list(map(int, input().split()))
*V, = list(map(int, input().split()))
m = min(N, K)
ans = 0
for left in range(m + 1):
_r = m - left
for right in range(_r + 1):
rest = K - left - right
take = V[:left] + V[N - right:]
... | p03032 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, ... | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline()... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
answer = 0
limit = min(N, K)
for a in range(limit+1): #左から取り出す
for b in range(limit-a+1): #右から取り出す
for c in range(K-(a+b)+1):
use = V[:a] + V[N-b:]
use.sort()
s = sum(use[c:])
... | import sys
sys.setrecursionlimit(10 ** 9)
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
V2 = V * 2
answer = 0
for i in range(1, min(N, K)+1): # iは宝石を取り出す個数
for j in range(0, min(i, K-i)+1): # jは何個の宝石を手離すか
for k in range(max(0, N-i), N+1): # V2の中で何番目から取り出すか
... | p03032 |
# coding: utf-8
import sys
sys.setrecursionlimit(10 ** 7)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 持っている宝石をDに詰めるのは最後
N, K = lr()
V = lr()
answer = 0
V = V[::-1] + V[::-1]
for x in range(K+1):
# x回Dから取り出す、K-x回戻すことが可能
x = min(x,... | # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, K = lr()
V = lr()
scores = [0]
limit = min(N, K)
for i in range(limit+1): # iは左から取り出す個数
for j in range(limit-i+1): # jは右から取り出す個数
stone = V[:i] + V[N-j:]
... | p03032 |
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, K = lr()
V = lr()
scores = [0]
limit = min(N, K)
for i in range(limit+1): # iは左から取り出す個数
for j in range(limit-i+1): # jは右から取り出す個数
stone = V[:i] + V[N-j:]
... | # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, K = lr()
V = lr()
answer = 0
limit = min(N, K)
for i in range(limit+1): # iは左から取り出す個数
for j in range(limit-i+1): # jは右から取り出す個数
stone = V[:i] + V[N-j:]
... | p03032 |
# https://atcoder.jp/contests/abc128/abc128_d
import itertools as it
N, K = list(map(int, input().split()))
vs = [int(s) for s in input().split()]
acc = [0] + list(it.accumulate(vs))
res = 1000000000
for left in range(min(N, K) + 1):
for right in range(min(N, K) + 1 - left):
tmp = acc[N - right]... | import itertools as it
n, k = list(map(int, input().split()))
vs = [int(s) for s in input().split()]
vs_acc = [0] + list(it.accumulate(vs))
vs_total = vs_acc[-1]
ans = 0
for left in range(min(n, k) + 1):
for right in range(min(n, k) - left + 1):
cnt = k - (left + right)
remaining = vs_a... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
rs = []
def check(k, v, current):
global rs
rs += [sum(current)]
if 0 == k:
return
else:
if current:
mc = min(current)
if mc < 0:
i = current.index(mc)
check(k - 1, v + [mc], current[:i] + current[i + 1:])
... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
vmax = 0
for l in range(0, K + 1):
for r in range(0, K - l + 1):
if N < l + r:
break
tv = V[:l] + V[N - r:]
#print(tv)
tv.sort()
for n in range(min(len(tv), K - (l + r))):
if tv[n] < 0:
tv[n] = 0
vmax = max(... | p03032 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.r... | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.r... | p03032 |
N, K = list(map(int, input().split()))
List = list(map(int, input().split()))
ans = [0]
for i in range(min(N, K)+1):
for j in range(min(N, K)-i+1):
if j==0:
temp = List[:i]
else:
temp = List[:i]+List[-j:]
for k in range(min(i+j, K-(i+j))+1):
an... | N, K = list(map(int, input().split()))
List = list(map(int, input().split()))
ans = 0
for i in range(min(N, K)+1):
for j in range(min(N, K)-i+1):
if j==0:
temp = List[:i]
else:
temp = List[:i]+List[-j:]
for k in range(min(i+j, K-(i+j))+1):
ret ... | p03032 |
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
vmax = -10**9
for n1 in range(K+1):
A = V[:n1]
ind = min(n1,N)
m = N-ind
for n2 in range(min(K-n1,m)+1):
B = V[N-n2:]
C = A+B
C = sorted(C,reverse=True)
k = K-n1-n2
for i in range(... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
vmax = 0
for i in range(K+1):
for j in range(K-i+1):
cnt = sum(V[:j])
A = V[:j]
n = N-(K-i-j)
if n>=j:
cnt += sum(V[n:])
A += V[n:]
else:
cnt += sum(V[j:])
... | p03032 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.std... | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.std... | p03032 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
# 再帰関数でいけそうだぞい
def dfs(que, cost, value):
if cost <= 0:
return value
elif len(que) > 1:
if que[0] < 0:
tmp1 = max(dfs(que[1:], cost-1, value+que[0]), dfs(que[1:], cost-2, value))
else:
... | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for a in range(min(n, k) + 1):
for b in range(min(n - a, k - a) + 1):
v_use = v[:a] + v[-b:] if b >= 1 else v[:a]
t = k - a - b
s = 0
for j in sorted(v_use):
if j < 0 and t > 0:
... | p03032 |
import copy
class MyClass():
maxSum = 0
def do(self, baseList, _temochi, leftIndex, rightIndex, nokoriSousaCount):
if nokoriSousaCount < 0:
return
sum = 0
minNum = 0
for each in _temochi:
sum += each
if each < 0 and each <... | class MyClass():
maxNumber = 0
def roop(self, baseList, opeCount):
listCount = len(baseList)
roopMax = listCount if listCount < opeCount else opeCount
for leftCount in range(0, roopMax):
self.getMax(baseList[0: leftCount + 1], opeCount - leftCount - 1)
... | p03032 |
import heapq
import copy
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
def dfs(q, have, count, operate):
if operate == 0:
heapq.heappush(have, q[0])
q = q[1:]
elif operate == 1:
heapq.heappush(have, q[-1])
q = q[:-1]
elif operate ... | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for a in range(min(n, k) + 1):
for b in range(min(n, k) - a + 1):
li = v[:a]
if b > 0:
li += v[-b:]
li.sort()
count = 0
while (a + b + count < k):
if len(li... | p03032 |
# -*- coding:utf-8 -*-
import copy
def solve():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
M = min(N,K)
for l in range(M+1):
having = []
for r in range(M+1):
if l+r > M: break
if l+r == 0: continue
... | # -*- coding:utf-8 -*-
def solve():
N, K = list(map(int, input().split()))
Vs = list(map(int, input().split()))
"""方針
Dequeueから宝石をとる。最後に好きなだけ宝石を戻す。
dp[i][j] := 左からi個、右からj個取ったときの最大値
"""
dp = [[0 for _ in range(K+1)] for __ in range(K+1)]
dp[0][0] = 0 # dpを使ってなくて草
ans ... | p03032 |
# -*- coding:utf-8 -*-
import sys
import heapq
def solve():
N, K = list(map(int, sys.stdin.readline().split()))
Vs = list(map(int, sys.stdin.readline().split()))
ans = 0
for i in range(0, K+1):
for j in range(0, K+1):
if i+j > K: break
if i+j > N: break
... | # -*- coding:utf-8 -*-
import sys
import heapq
def solve():
N, K = list(map(int, sys.stdin.readline().split()))
Vs = list(map(int, sys.stdin.readline().split()))
ans = 0
for i in range(0, K+1):
for j in range(0, K+1):
if i+j > K: break
if i+j > N: break
... | p03032 |
from itertools import accumulate
N, K = list(map(int, input().split()))
*V, = list(map(int, input().split()))
ans = 0
for a in range(N+1):
for b in range(N+1):
if a+b>N:continue
if a and b:
qa, qb = list(accumulate([0]+sorted(V[:a]))), list(accumulate([0]+sorted(V[-b:... | from itertools import accumulate
N, K = list(map(int, input().split()))
*V, = list(map(int, input().split()))
ans = 0
for a in range(N+1):
for b in range(N+1):
if a+b>N:continue
t = []
if a:
t += V[:a]
if b:
t += V[-b:]
t.sort()
... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
score = {}
def Compute(n, D, S):
D2 = tuple(D)
S2 = tuple(S)
if (n, D2, S2) in score:
return score[(n, D2, S2)]
if n == 0:
return sum(S)
candidate = [Compute(n - 1, D, S)]
if len(D) > 0:
... | import bisect
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
score = -1e100
M = min(N, K)
for A in range(0, M + 1):
for B in range(0, M - A + 1):
S = []
if A > 0:
S += V[:A]
if B > 0:
S += V[-B:]
S.sort()
... | p03032 |
n,k,*v=list(map(int,open(0).read().split()))
m=0
r=range
for i in r(n+1):
for j in r(min(k,n)-i+1):
t=sorted(v[:i]+v[-j:]*(j>0))
while t and(k-i-j)*t[0]<0:t.pop(0);j+=1
m=max(m,sum(t))
print(m) | n,k,*v=list(map(int,open(0).read().split()))
m=0
r=range
for i in r(n+1):
for j in r(min(k,n)-i+1):
t=sorted(v[:i]+v[::-1][:j])
while t and(k-i-j)*t[0]<0:t.pop(0);j+=1
m=max(m,sum(t))
print(m) | p03032 |
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
import heapq
ans = 0
for a in range(min(N,K)+1):
for b in range(min(N,K)-a+1):
A = V[:a] + V[N-b:]
heapq.heapify(A)
for c in range(min(a+b, K-a-b)):
small = heapq.heappop(A)
if small >... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
Vrev = V[::-1]
ans = 0
for a in range(N+1):
for b in range(min(K-a,N-a)+1):
VV = V[:a] + Vrev[:b]
VV.sort(reverse=True)
for k in range(min(K-a-b,len(VV))):
if VV[-1] < 0:
VV.pop()
... | p03032 |
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = 0
for l in range(N):
for r in range(N-l+1):
arr = V[:l] + ([] if r==0 else V[-r:])
k = len(arr)
if k > K: continue
score = sum(arr)
arr.sort()
i = 0
while k < K and i < len(arr):
if arr[i] >= ... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = 0
for l in range(N):
if l > K: break
for r in range(N-l+1):
if l+r > K: break
vs = V[:l] + (V[-r:] if r>0 else [])
vs.sort()
k = K-l-r
t = 0
for v in vs:
if v <... | p03032 |
def main():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for left in range(K+1):
for right in range(K+1):
if left + right > K:
continue
tmp = []
for i in range(min(N, left)):
tmp... | def main():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for i in range(K+1):
cand = []
for left in range(i+1):
cand = V[:left]
right = i - left
cand += V[max(left,N-right):N]
cnt = K - i
... | p03032 |
# -*- coding: utf-8 -*-
"""
"""
import sys
from collections import deque
from functools import lru_cache
@lru_cache(maxsize=None)
def dig_left(n, q):
res = [0]
for di in range(1, min(n, len(q))+1):
bu = n - di
dig = list(q[:di])
dig.sort()
while bu and di... | # -*- coding: utf-8 -*-
"""
D - equeue
https://atcoder.jp/contests/abc128/tasks/abc128_d
"""
import sys
def dig_lr(n, q, lr='L'):
# 左(もしくは右)側から最大でn回操作した時の結果の最大値を求める
res = [0]
for di in range(1, min(n, len(q))+1): # diは最大で掘る回数
bu = n - di # 埋める方に使用する操作回数
dig = l... | p03032 |
#python3
from collections import deque
from heapq import heappop, heappush
def main():
n, k = list(map(int, input().split()))
vs = [int(i) for i in input().split()]
ans = 0
for l in range(k+1):
for r in range(k-l+1):
dl = k-l-r
q = deque(vs)
hav = [... | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from heapq import heapify, heappop, heappush
def main():
N, K = list(map(int, readline().split()))
V = [int(i) for i in readline().split()]
A = V[::-1]
ans = 0
for l in rang... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
s = 0
for i in range(min(K, N)+1):
res = K - i
for j in range(i+1):
k = i - j
Q = sorted(V[:j] + V[N-k:])
minus = sum([q < 0 for q in Q])
score = sum(Q[min(minus, res):])
s = max(s, s... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
s = 0
for i in range(min(K, N)+1):
r = K - i
for j in range(i+1):
k = i - j
Q = sorted(V[:j] + V[N-k:])
m = sum([q < 0 for q in Q])
s = max(s, sum(Q[min(m, r):]))
print(s)
| p03032 |
n,k = list(map(int,input().split()))
v = list(map(int,input().split()))
m=[]
for i in range(k+1):
for j in range(min(k,n)-i+1):
# print(i,j)
t=sorted(v[:i]+v[:~j:-1])
while t and(k-i-j)*t[0]<0:t.pop(0);j+=1
m+=sum(t),
print((max(m)))
| n,k = list(map(int,input().split()))
v = list(map(int,input().split()))
m=[]
for i in range(k+1):
for j in range(min(k,n)-i+1):
# print(i,j)
t=sorted(v[:i]+v[:~j:-1])
while t and(k-i-j)*t[0]<0:t.pop(0);j+=1
m.append(sum(t))
print((max(m)))
| p03032 |
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
import heapq
m = min(N,K)
M = 0
for i in range(m+1):
for j in range(m-i+1):
v1 = V[:i]
v3 = V[N-j:]
# print(v1,v3)
v = v1+v3
heapq.heapify(v)
h = K - len(v)
while v and len(v... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
import heapq
m = min(N,K)
M = 0
for i in range(m+1):
for j in range(m-i+1):
v1 = V[:i]
v3 = V[N-j:]
v = v1+v3
heapq.heapify(v)
h = K - len(v)
while v and h >0:
q = heapq... | p03032 |
import heapq
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
m = min(N,K) #KがNより大きい場合を防ぐ
M = 0
for i in range(m+1):
for j in range(m-i+1):
A1 = A[:i] #前から取る
A3 = A[N-j:] #後ろから取る
new_A = A1+A3
new_A.sort(reverse=True)
h = K - len(new_A)
... | N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
m = min(N,K)
M = 0
for i in range(m+1):
for j in range(m-i+1):
v=A[:i]+A[N-j:]
v.sort()
v=v[::-1]
h=K-len(v)
while h >0 and v:
if v[-1] > 0:
break
els... | p03032 |
from bisect import bisect_left
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
act = min(N, K)
ans = - 10 ** 19
for i in range(act + 1):
for a in range(i + 1):
for b in range(i - a + 1):
itm = []
itm += V[:a]
itm += V[N-b:]
itm.sort()
idx = ... | n, k = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = - 10 ** 19
# i: Dから取り出す宝石の個数
for i in range(min(k + 1, n + 1)):
# j: 左からとる個数(i-jが右からとる個数)
for j in range(i + 1):
inhands = V[:j] + V[n - i + j:]
inhands.sort()
remnum = k - i
val = 0
for h in inhands:
... | p03032 |
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
U = V[::-1]
ret = 0
m = min(N, K)
for l in range(m+1):
for r in range(m+1-l):
hold = V[:l] + U[:r]
hold.sort()
for d in range(K+1-l-r):
ret = max(ret, sum(hold[d:]))
print(ret) | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ret = 0
m = min(N, K)
for l in range(m+1):
for r in range(m+1-l):
hold = V[:l] + V[N-r:]
hold.sort()
for d in range(K+1-l-r):
ret = max(ret, sum(hold[d:]))
print(ret) | p03032 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
# 左から何個、右から何個を全探索
ans = 0
for l in range(0, k + 1):
for r in range(0, k + 1 - l):
if l + r > n:
continue
suteru = k - l - r
get = []
for i in range(l):
get.append(v[i])
... | n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for l in range(0, k + 1):
for r in range(0, k + 1 - l):
if l == r == 0 or l + r > n:
continue
a = sorted(v[:l] + v[n - r:])
m = min(k - l - r, len(a) - 1)
ans = max(ans, sum(a[m:... | p03032 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for a in range(min(n, k)+1):
for b in range(min(n, k)-a+1):
bag = []
bag += v[:a]
bag += v[len(v)-b:]
bag.sort()
if len(bag) > 0:
for c in range(k-a-b):
if bag[0] < 0:
bag.pop(0)
... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for i in range(K+1):
for j in range(N, max(N-1-(K-i), i-1), -1):
bag = []
bag += V[:i] + V[j:]
bag.sort()
idx = 0
if len(bag) == 0:
continue
if len(bag) == 1:
ans = max(ans, sum(bag))
... | p03032 |
import heapq
N, K = [int(_) for _ in input().split()]
V = [int(_) for _ in input().split()]
ans = 0
for il in range(min([N + 1, K + 1])):
for ir in range(min([N + 1 - il, K + 1 - il])):
for dl in range(il + 1):
for dr in range(ir + 1):
if il + ir + dl + dr > K:
... | import heapq
N, K = [int(_) for _ in input().split()]
V = [int(_) for _ in input().split()]
ans = 0
for il in range(K + 1):
for ir in range(K + 1 - il):
if il + ir > min([N, K]):
continue
H = V[:il] + V[N - ir:N]
heapq.heapify(H)
now = 0
for d in range(... | p03032 |
n, k = list(map(int, input().split()))
vs = list(map(int, input().split()))
from collections import deque
from heapq import heappush, heappop
from itertools import product
res = 0
for comb in product([1, 2, 3, 4], repeat=k):
dq = deque(vs)
hq = []
valid = True
for i in range(k):
... | n, k = list(map(int, input().split()))
vs = list(map(int, input().split()))
from collections import deque
from heapq import heappush, heappop
res = 0
for i in range(0, min(k, n) + 1):
for j in range(i + 1):
a = j
b = i - j
hq = []
dq = deque(vs)
for _ in ... | p03032 |
from copy import deepcopy
N, K = list(map(int, input().split()))
V = tuple(map(int, input().split()))
all_score = sum(V)
memo = {}
def dfs(queue, hand, depth):
# print(queue, hand, depth)
if depth == K:
score = all_score - sum(queue)
memo[queue] = score
# print('return', ... | from copy import deepcopy
N, K = list(map(int, input().split()))
V = tuple(map(int, input().split()))
max_score = -1000000000
for i in range(K+1):
for j in range(K - i + 1):
if i + j > N:
continue
# 左からi個取る
hand = list(V[:i])
# 右からj個取る
hand.extend(V[N... | p03032 |
import copy
N, K = list(map(int, input().split()))
V = [int(i) for i in input().split()]
value = 0
# k+1個取って，ret-1個戻す
num = min(N*2,K)
for k in reversed(list(range(num))):
for ret in range(num-k): #戻す個数はret個
if (ret < k+1):
#print('{}個取って{}戻す'.format(k+1,ret))
for i in ... | import copy
N, K = list(map(int, input().split()))
V = [int(i) for i in input().split()]
result = 0
# i個取る
for i in range(min(N,K)+1):
#print('i:',i)
for sp in range(i+1): # 左右の分け方
#print('right',sp)
#print('left',i-sp)
tmp = []
V_tmp = copy.copy(V)
#print... | p03032 |
import heapq
N,K=list(map(int, input().split()))
V=list(map(int, input().split()))
ans=-10**9
for l in range(min(N,K)+1):
for r in range(max(1,min(N,K)+1-l)):
for d in range(max(1,K+1-l-r)):
h=V[:l]
heapq.heapify(h)
for i in range(r): heapq.heappush(h, V[-1-i])... | import heapq
N,K=list(map(int, input().split()))
V=list(map(int, input().split()))
ans=-10**9
for l in range(min(N,K)+1):
for r in range(max(1,min(N,K)+1-l)):
for d in range(max(1,min(N,K-l-r)+1)):
h=V[:l]
heapq.heapify(h)
for i in range(r): heapq.heappush(h, V... | p03032 |
import bisect
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = 0
if N < K :
pp = K
K = N
else :
pp = K
for a in range(1,K+1) :
for i in range(a+1) :
G = []
G.extend(V[:i])
G.extend(V[len(V)-(a-i):])
G.append(0)
G =... | N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = 0
P = min(N,K)
for a in range(1,P+1) :
for i in range(a+1) :
cnt = 0
calc = 0
GET = V[:i] + V[N-(a-i):]
GET = sorted(GET)
for g in GET :
if (g < 0) and (cnt < ... | p03032 |
from heapq import heappop, heapify
N, K, *V = list(map(int, open(0).read().split()))
# i: 操作回数
# j: 取り出す個数
# k: 左から取り出す範囲 [0, k)
ans = 0
for i in range(K + 1):
for j in range(min(N + 1, i + 1)):
for k in range(j + 1):
right = N - j + k
tmp = V[:k] + V[right:]
... | N, K, *V = list(map(int, open(0).read().split()))
# i: 操作回数
# j: 取り出す個数
# k: 左から取り出す範囲 [0, k)
ans = 0
for i in range(K + 1):
for j in range(min(N + 1, i + 1)):
for k in range(j + 1):
right = N - j + k
tmp = V[:k] + V[right:]
tmp.sort()
ans = max(a... | p03032 |
import copy
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
INF = 10 ** 8
def rec(rest_ope, now_d, now_hand):
if rest_ope == 0:
return sum(now_hand)
max_price = -INF
if len(now_d) > 0:
left_d = copy.copy(now_d)
left_hand = copy.copy(... | import copy
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
INF = 10 ** 8
# mode 0: can pop left, pop right, drop
# 1: can pop right, drop
# 2: can drop
# 3: can not do anything
def rec(rest_ope, now_d, now_hand, mode):
if rest_ope == 0:
return s... | p03032 |
def sousa(k,hand,v):
if k==0:
# print(k,sum(hand),hand,v)
ans.append(sum(hand))
return
if len(v)>0:
# 左から取る
sousa(k-1,hand+[v[0]],v[1:])
# 右から取る
sousa(k-1,hand+[v[-1]],v[:-1])
if len(hand)>0:
# 右に入れる
hand.sort()
a... | n,k=list(map(int,input().split()))
v=list(map(int,input().split()))
ans=[]
for lhs in range(k+1):
for rhs in range(k-lhs+1):
if lhs+rhs<=n:
array=v[:lhs]+v[n-rhs:]
else:
array=v[:]
# print(v[:lhs],v[n-rhs:])
for i in range(k+1-lhs-rhs):
... | p03032 |
import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
_V = V[::-1]
ans = 0
for k in range(K + 1):
n_pop = min(k, N)
n_push = K - n_pop
for i in range(n_pop + 1):
l, r = i, n_... | import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = -float("inf")
for t in range(min(N, K) + 1):
s = K - t
for l in range(t + 1):
r = t - l
gem = V[:l]
ge... | p03032 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
de... | import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=1000000007
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.std... | p03032 |
mod = 10 ** 9 + 7
from collections import deque
import heapq
def iip(listed):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def main():
r = solve()
print(r)
def solve():
N, K = iip(False)
V = iip(True)
... | mod = 10 ** 9 + 7
from collections import deque
import heapq
def iip(listed):
ret = [int(i) for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def main():
r = solve()
print(r)
def solve():
N, K = iip(False)
V = iip(True)
... | p03032 |
import itertools
n,k=list(map(int,input().split()))
d=list(map(int,input().split()))
oll=list(itertools.product(['a','b','c','d'],repeat=k))
ans=0
for ol in oll:
tv=0
t=[]
td=d[:]
for o in ol:
if o=='a':
t+=[td.pop(0)]
tv=sum(t)
ans=max(ans,tv)
... | n,k=list(map(int,input().split()))
d=list(map(int,input().split()))
ans=0
for l in range(min(n,k)+1):
for r in range(min(n-l,k-l)+1):
tl=d[:l]+d[-r:] if r>0 else d[:l]
tk=k-l-r
s=0
for t in sorted(tl):
if t<0 and tk>0:
s+=-t
tk-=... | p03032 |
from collections import deque
import copy
dp = {}
def dfs(N, K, k, have, q):
if k == K:
return sum(have)
else:
if not ((k, tuple(q)) in dp):
a = [sum(have)]
if len(q) > 0:
tmp_q = copy.copy(q)
tmp_have = copy.copy(have)
v = tmp_q.popleft()
tmp_have.... | N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
M = min(N, K)
ans = 0
for p in range(M+1):
for q in range(M-p+1):
left = []
right = []
if p > 0:
left = V[:p]
if q > 0:
right = V[-q:]
have = sorted((left+right).copy())
if len(have) > 0:
... | p03032 |
def main():
import collections
import copy
N,K = list(map(int, input().split()))
V = collections.deque(list(map(int, input().split())))
answer = [[0]*(K+1) for _ in range(K+1)]
for i in range(1,K+1):
for j in range(1,min(i+1,N+1)):
opt = 0
for k in ... | def main():
import collections
import copy
N,K = list(map(int, input().split()))
V = collections.deque(list(map(int, input().split())))
answer = [[0]*(K+1) for _ in range(K+1)]
for i in range(1,K+1):
for j in range(max(1,i//2),min(i+1,N+1)):
opt = 0
... | p03032 |
from itertools import product
from collections import deque
def state_brute_force(state, count):
state_list = [state for _ in range(count)]
for s in product(*state_list):
yield s
N, K = list(map(int, input().split()))
D = list(map(int, input().split()))
ans = 0
pop_l = deque.popleft
... | N, K = list(map(int, input().split()))
D = list(map(int, input().split()))
ans = 0
for left in range(K + 1):
for right in range(K - left + 1):
if left + right > N:
break
items = list(D[0:left])
items.extend(D[::-1][0:right])
dis = K - (left + right)
... | p03032 |
# import string
import unittest
from io import StringIO
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for l in range(K+1):
for r ... | import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N, K = list(map(int, input().split()))
V = list(map(int, input().split()))
ans = 0
for l in range(K+1):
for r in range(K-l+1):
if l+r > N or l+r>K:
... | p03032 |
import heapq
from collections import deque
from functools import lru_cache
N,K = list(map(int,input().split()))
lim = min(N,K)
V = list(map(int,input().split()))
D = V.copy()
have = []
heapq.heapify(have)
#@lru_cache(maxsize = None)
def recur(d,h,n):
if n == lim:
#print(h)
return sum(h)
el... | import heapq
from collections import deque
from functools import lru_cache
N,K = list(map(int,input().split()))
V = list(map(int,input().split()))
ans = 0
for l in range(0,K + 1):
for r in range(0,K - l + 1):
d = K - r - l
tmp = 0
have = []
if l + r > N:
continue
for i in ra... | p03032 |
def gcd(a,b):
i = 2
temp = 1
while(i <= b):
while(a % i == 0 and b % i == 0):
temp = temp * i
a = a / i
b = b / i
if(i % 2 == 0):
i = i + 1
else:
i = i + 2
print(temp)
l = input().split()
if(int(l[0]) > i... | def gcd(a,b):
if(b):
return gcd(b,a%b)
return a
l = input().split()
if(int(l[0]) > int(l[1])):
print(gcd(int(l[0]),int(l[1])))
else:
print(gcd(int(l[1]),int(l[0])))
| p02256 |
a, b = list(map(int, input().split()))
c = []
if a > b:
a, b = b, a
while True:
for i in range(a):
#print(a, i)
x = i + 2
if a%x == 0:
if b%x == 0:
c.append(x)
a = a//x
b = b//x
#print(c)
... | a, b = list(map(int, input().split()))
c = []
if a > b:
a, b = b, a
if b%a == 0:
print(a)
else:
while True:
for i in range(a):
x = i + 2
#print(a, x)
if a%x == 0:
if b%x == 0:
c.append(x)
a = a/... | p02256 |
import sys
import math
(a, b) = tuple([int(s) for s in input().split()])
if a==b:
print(a)
sys.exit(0)
min = a if a < b else b
divisor = 1
i = 2
while i < math.sqrt(min):
if a % i == 0 and b % i == 0:
a = a / i
b = b / i
divisor = divisor * i
else:
... | # 1_1_B
def gcd(x, y):
while x%y != 0:
x, y = y, x%y
return y
x, y = list(map(int, input().split()))
print((gcd(x, y))) | p02256 |
x, y = list(map(int, input().split()))
n = min(x, y)
for i in range(1, n+1):
if x%i==0 and y%i==0:
gcd = i
print(gcd) | x, y = list(map(int, input().split()))
a = max(x, y)
b = min(x, y)
if a%b==0:
gcd = b
else:
for i in range(1, a%b+1):
if b%i==0 and (a%b)%i==0:
gcd = i
print(gcd) | p02256 |
x, y = list(map(int, input().split()))
a = max(x, y)
b = min(x, y)
if a%b==0:
gcd = b
else:
for i in range(1, a%b+1):
if b%i==0 and (a%b)%i==0:
gcd = i
print(gcd) | x, y = list(map(int, input().split()))
a = max(x, y)
b = min(x, y)
while a%b != 0:
temp = a
a = b
b = temp%b
print(b) | p02256 |
a, b = list(map(int, input().split()))
def gcd(a, b):
if a == b:
return a
big = max(a, b)
small = min(a, b)
big_i = big % small
herf = round(min(small, big_i))
for i in range(herf, 1, -1):
if small%i==0 and big_i%i==0:
return i
return 1
print((... | a, b = list(map(int, input().split()))
def gcd(a, b):
if a == b:
return a
big = max(a, b)
small = min(a, b)
while not big % small == 0:
big, small = small, big%small
return small
print((gcd(a, b)))
| p02256 |
a,b = list(map(int,input().split()))
def gcd(x,y):
z = max(x,y) % min(x,y)
if z == 0 :
return [min(x,y),0]
return gcd(max(x,y),z)
L = gcd(a,b)
K = []
for i in reversed( (list(range(1,L[0]+1))) ) :
if a % i == 0 and b % i == 0:
K.append(i)
print((max(K)))
| a,b = list(map(int,input().split()))
def gcd(x,y):
q = max(x,y) % min(x,y)
if q == 0 :
return [min(x,y),0]
return gcd(min(x,y),q)
L = gcd(a,b)
K = [ i for i in reversed(list(range(1, L[0] +1))) if a % i == 0 ]
print((max(K)))
| p02256 |
a,b = list(map(int,input().split()))
def gcd(x,y):
q = max(x,y) % min(x,y)
if q == 0 :
return [min(x,y),0]
return gcd(min(x,y),q)
L = gcd(a,b)
K = [ i for i in reversed(list(range(1, L[0] +1))) if a % i == 0 ]
print((max(K)))
| a,b = list(map(int,input().split()))
def gcd(x,y):
q = max(x,y) % min(x,y)
if q == 0 :
return [min(x,y),0]
return gcd(min(x,y),q)
print((max(gcd(a,b))))
| p02256 |
def gcd(x, y):
a_x = list()
a_y = list()
for i in range(1, x+1):
if x % i == 0:
a_x.append(i)
for i in range(1, y+1):
if y % i == 0:
a_y.append(i)
a_cd = list(set(a_x).intersection(set(a_y)))
return max(a_cd)
if __name__ == "__main__":... | def gcd(x, y):
if x < y:
tmp = x
x = y
y = tmp
while y > 0:
r = x % y
x = y
y = r
return x
if __name__ == "__main__":
x, y = list(map(int, input().split()))
print((gcd(x, y))) | p02256 |
a,b = list(map(int,input().split()))
while a % b != 0:
a,b = b, a % b
print(b) | def gcm(x,y):
while y:
x, y = y, x % y
return x
a,b = list(map(int, input().split()))
print((gcm(a,b))) | p02256 |
x,y = list(map(int,input().split()))
if x==y:
print(x)
else:
if y>x:
tmp = x
x = y
y = tmp
i=2
ans = 1
al = []
while i<=x/2:
if x % i ==0:
if y % i==0:
al.append(i)
x = x/i
y = y/i
... | x,y = list(map(int,input().split()))
if x==y:
print(x)
else:
if y>x:
tmp = x
x = y
y = tmp
i=2
ans = 1
al = []
while i*i<=x:
if x % i ==0:
if y % i==0:
al.append(i)
x = x/i
y = y/i
... | p02256 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.