input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = 10**18
for l in range(N - K + 1):
D = X[l + K - 1] - X[l]
if X[l] <= 0 <= X[l + K - 1]:
D += min(-X[l], X[l + K - 1])
elif X[l + K - 1] <= 0:
D += -X[l + K - 1]
elif X[l] >= 0:
D += X[l]
ans = min(ans, D)
print(ans)
| N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = 10**18
for l, r in zip(X, X[K - 1:]):
if r <= 0:
ans = min(ans, abs(l))
if l >= 0:
ans = min(ans, abs(r))
if l < 0 < r:
ans = min(ans, r - l + min(abs(r), abs(l)))
print(ans)
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans=4*10**8
# zip関数は多い元は無視する.
for a, b in zip(x, x[k-1:]):
cand = b-a + min(abs(a), abs(b))
ans = min(cand, ans)
print(ans) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans=[0]*(n-k+1)
# zip関数は多い元は無視する.
for i, a, b in zip(list(range(n)), x, x[k-1:]):
ans[i] = b-a + min(abs(a), abs(b))
print((min(ans))) | p03274 |
x,y = list(map(int,input().split()))
t = list(map(int,input().split()))
ans = 1000000000000000000000000000000
for i in range(x-y+1):
hani = t[i:i+y]
if hani[0] <= 0 and 0 <= hani[-1]:
ans = min(ans, abs(hani[-1]*2)+abs(hani[0]), abs(hani[-1])+abs(hani[0]*2))
elif hani[-1] <= 0:
ans = min(ans, abs(hani[0]))
elif 0 <= hani[0]:
ans = min(ans, abs(hani[-1]))
print(ans) | N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float("inf")
for left in range(0, N-K+1):
right = left+K
minus = 0
plus = 0
if X[left] < 0:
minus = min(minus, X[left])
if X[right-1] > 0:
plus = max(plus, X[right-1])
ans = min(ans, 2*abs(minus)+plus, abs(minus)+2*plus)
print(ans) | p03274 |
N, K = list(map(int, input().split()))
X = [int(x) for x in input().split()]
import bisect
zero = bisect.bisect_left(X, 0)
left = max(zero - K, 0)
ans = float('inf')
while 1:
right = left+K-1
if left > zero + 1 or len(X) <= right: break
lv, rv = X[left], X[right]
if lv * rv > 0:
ans = min(ans, max(abs(rv), abs(lv)))
else:
ans = min(ans, min(rv*2 - lv, rv - lv*2))
left += 1
print(ans) | N, K = list(map(int, input().split()))
X = [int(x) for x in input().split()]
ans = float('inf')
for left in range(N - K + 1):
lv, rv = X[left], X[left+K-1]
if lv * rv > 0:
ans = min(ans, max(abs(rv), abs(lv)))
else:
ans = min(ans, min(rv*2 - lv, rv - lv*2))
print(ans) | p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
if 0 in x:
K -= 1
x.remove(0)
Min = -1
for i in x:
goal = i
if goal > 0:
path = [j for j in x if j < goal]
if len(path) < K-1:
pass
else:
path = path[-K+1:]
le = min(path)
dis = abs(0-le)+abs(goal-le)
if Min == -1:
Min = dis
else:
if dis < Min:
Min = dis
else:
path = [j for j in x if j > goal]
if len(path) < K-1:
pass
else:
path = path[:K-1]
re = max(path)
dis = abs(0-re)+abs(goal-re)
if Min == -1:
Min = dis
else:
if dis < Min:
Min = dis
if Min == -1:
Min = 0
print(Min)
| N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
Min = 10**9
for i in range(N-K+1):
x_l = x[i]
x_r = x[i+K-1]
ans_1 = abs(x_l-0) + abs(x_l-x_r)
ans_2 = abs(x_r-0) + abs(x_l-x_r)
Min = min(Min, ans_1, ans_2)
print(Min)
| p03274 |
import itertools as ito
N,K=list(map(int,input().split(" ")))
X=list(map(int,input().split(" ")))
Ex=list(ito.permutations(X,K))
ans=0
for i in range(len(Ex)):
tans=0
tx=0
for j in range(len(Ex[i])):
tans+=abs(tx-Ex[i][j])
tx=Ex[i][j]
if tans<ans or i==0:
ans=tans
print(ans) | N,K=list(map(int,input().split(" ")))
X=sorted(list(map(int,input().split(" "))))
ans=0
for i in range(N-K+1):
tans=abs(X[i]-X[i+K-1])+abs(X[i])
if i==0 or ans>tans:
ans=tans
for i in range(N-K+1):
tans=abs(X[i]-X[i+K-1])+abs(X[i+K-1])
if ans>tans:
ans=tans
print(ans) | p03274 |
import bisect
import sys
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
index = bisect.bisect_left(x,0)
if x[0] >= 0 :
print((x[k-1]))
sys.exit()
if x[-1] <= 0 :
print((x[n-k]*(-1)))
sys.exit()
ans = 10**9
if min(index+k,n) == index+k :
ans = x[index+k-1]
if max(0,index-k) == index - k :
ans = min(ans,x[index-k]*(-1))
c = 0
for i in range(index,min(index+k,n)) :
c += 1
if i <= n-1 and i-(k-1) <= n-1 and i-(k-1) >= 0 :
ans = min(ans,x[i]*2+x[i-(k-1)]*(-1))
c = 0
for i in range(max(0,index-k),index) :
c += 1
if i <= n-1 and i+(k-1) <= n-1 :
ans = min(ans,x[i]*(-1)*2+x[i+(k-1)])
print(ans) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**9
for i in range(n-k+1) :
xs = abs(x[i+k-1]-x[i])
ans = min(ans,xs+abs(x[i]),xs+abs(x[i+k-1]))
print(ans) | p03274 |
N,K = list(map(int,input().split()))
X = [int(i) for i in input().split()]
X_sub = [[] for i in range(N-K+1)]
for i in range(N-K+1):
X_sub[i] = X[i:i+K]
min_cost = float('inf')
for i in X_sub:
tmp_l = abs(i[0]) + abs(i[-1]-i[0])
tmp_r = abs(i[-1]) + abs(i[0]-i[-1])
tmp = min(tmp_l,tmp_r)
if min_cost > tmp:
min_cost = tmp
print(min_cost) | N,K = list(map(int,input().split()))
X = [int(i) for i in input().split()]
min_cost = float('inf')
for i in range(N-K+1):
sub_x = X[i:i+K]
tmp_l = abs(sub_x[0]) + abs(sub_x[-1]-sub_x[0])
tmp_r = abs(sub_x[-1]) + abs(sub_x[0]-sub_x[-1])
tmp = min(tmp_l,tmp_r)
if min_cost > tmp:
min_cost = tmp
print(min_cost)
| p03274 |
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=10**9
for i in range(n-k+1):
if x[i+k-1]<0:
ans=min(ans,-x[i])
elif x[i]>0:
ans=min(ans,x[i+k-1])
else:
ans=min(ans,2*x[i+k-1]-x[i],2*(-x[i])+x[i+k-1])
print(ans) | import sys
input = sys.stdin.buffer.readline
input = sys.stdin.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
#import numpy as np
def main():
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=10**18
for i in range(n):
try:
l=x[i]
r=x[i+k-1]
if r<0:
ans=min(ans,-l)
elif l>0:
ans=min(ans,r)
else:
ans=min(ans,r-l+min(-l,r))
except:
pass
print(ans)
if __name__ == "__main__":
main()
| p03274 |
import sys
input = sys.stdin.buffer.readline
input = sys.stdin.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
#import numpy as np
def main():
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=10**18
for i in range(n):
try:
l=x[i]
r=x[i+k-1]
if r<0:
ans=min(ans,-l)
elif l>0:
ans=min(ans,r)
else:
ans=min(ans,r-l+min(-l,r))
except:
pass
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
#input = sys.stdin.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
#import numpy as np
def main():
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=10**18
for i in range(n):
try:
l=x[i]
r=x[i+k-1]
if r<0:
ans=min(ans,-l)
elif l>0:
ans=min(ans,r)
else:
ans=min(ans,r-l+min(-l,r))
except:
pass
print(ans)
if __name__ == "__main__":
main()
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
if x[0] >= 0:
print((x[k - 1]))
exit()
elif x[n - 1] < 0:
print((abs(x[n - k])))
exit()
else:
for i in range(n):
if x[i] >= 0:
ori = i
break
f_inf = float("inf")
res = f_inf
for i in range(max(ori - k, 0), min(ori + k, n) - k + 1):
time = min(abs(x[i + k - 1] - x[i]) + abs(x[i + k - 1]), abs(x[i]) + abs(x[i + k - 1] - x[i]))
res = min(res, time)
print(res)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
if X[0] >= 0:
print((X[k - 1]))
exit()
elif X[-1] < 0:
print((abs(X[n - k])))
exit()
else:
for i in range(n):
if X[i] >= 0:
ori = i
break
res = f_inf
left = max(ori - k, 0)
right = min(ori + k, n)
for i in range(left, right - k + 1):
RL = abs(X[i + k - 1] - X[i]) + abs(X[i + k - 1])
LR = abs(X[i]) + abs(X[i + k - 1] - X[i])
res = min(res, min(RL, LR))
print(res)
if __name__ == '__main__':
resolve()
| p03274 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
if X[0] >= 0:
print((X[k - 1]))
exit()
elif X[-1] < 0:
print((abs(X[n - k])))
exit()
else:
for i in range(n):
if X[i] >= 0:
ori = i
break
res = f_inf
left = max(ori - k, 0)
right = min(ori + k, n)
for i in range(left, right - k + 1):
RL = abs(X[i + k - 1] - X[i]) + abs(X[i + k - 1])
LR = abs(X[i]) + abs(X[i + k - 1] - X[i])
res = min(res, min(RL, LR))
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
for i in range(n):
if X[i] >= 0:
ori = i
X.insert(ori, 0)
break
else:
ori = n
X.insert(ori, 0)
res = f_inf
start = max(0, ori - k)
end = min(n - k + 1, ori + 1)
for j in range(start, end):
left = abs(X[j]) * 2 + abs(X[j + k])
right = abs(X[j]) + abs(X[j + k]) * 2
res = min(res, min(left, right))
print(res)
if __name__ == '__main__':
resolve()
| p03274 |
N,K = list(map(int, input().split()))
X = [int(x) for x in input().split()]
ref = []
for i in range(N-K+1):
ref.append(X[i:i+K])
List = []
for j in range(N-K+1):
if X[j]<=0 and X[j+K-1]>=0:
List.append(X[j+K-1]-X[j]+min(abs(X[j]),X[j+K-1]))
else:
List.append(max(abs(X[j]),abs(X[j+K-1])))
print((min(List))) | N,K = list(map(int, input().split()))
X = [int(x) for x in input().split()]
List = []
for j in range(N-K+1):
if X[j]<=0 and X[j+K-1]>=0:
List.append(X[j+K-1]-X[j]+min(abs(X[j]),X[j+K-1]))
else:
List.append(max(abs(X[j]),abs(X[j+K-1])))
print((min(List))) | p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 3*10**8
for i in range(N-K+1):
ans1 = abs(x[i])+abs(x[i]-x[i+K-1])
ans2 = abs(x[i+K-1])+abs(x[i]-x[i+K-1])
ans = min(ans, ans1, ans2)
print(ans) | N, K = list(map(int, input().split()))
x = [int(i) for i in input().split()]
ans = x[K - 1] - x[0] + min(abs(x[0]), abs(x[K - 1]))
for i in range(N - K + 1):
ans = min(ans, x[K + i -1] - x[i] + min(abs(x[K + i -1]), abs(x[i])) )
print(ans) | p03274 |
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
import bisect
c=bisect.bisect_left(x,0)
mt=2*10**8
for i in range(n-k+1):
if i+k<c:continue
mt=min(mt,2*abs(x[i])+abs(x[i+k-1]),abs(x[i])+2*abs(x[i+k-1]))
if i+k-1 ==c-1:mt=min(mt,abs(x[i]))
if i==c:mt=min(mt,x[i+k-1])
if n==k:
if c!=n and c!=0:
mt=min(2*abs(x[0])+x[-1],2*x[-1]+abs(x[0]))
else:
mt=max(abs(x[0]),abs(x[-1]))
print(mt)
| n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
mt=5*10**8
for i in range(n-k+1):
mt=min(mt,2*abs(x[i])+abs(x[i+k-1]),abs(x[i])+2*abs(x[i+k-1]))
if x[0]>0:mt=min(mt,x[k-1])
elif x[-1]<0:mt=min(mt,abs(x[-1-k+1]))
print(mt)
| p03274 |
import bisect
n,k = list(map(int, input().split()))
x = list(map(int, input().split()))
z = bisect.bisect_left(x,0)
ans=10**12
s=z-k+1
if s < 0:
s=0
if z == 0:
z+=1
for i in range(s,z):
t=x[i:i+k]
xl=min(t)
xr=max(t)
ans=min(ans,abs(xr)+abs(xr-xl),abs(xl)+abs(xr-xl))
print(ans) | import bisect
n,k = list(map(int, input().split()))
x = list(map(int, input().split()))
z = bisect.bisect_left(x,0)
ans=10**12
s=z-k
if s < 0:
s=0
g=z+1
if g+k >= n:
g=n-k+1
for i in range(s,g):
xl=x[i]
xr=x[i+k-1]
ans=min(ans,abs(xr)+abs(xr-xl),abs(xl)+abs(xr-xl))
print(ans) | p03274 |
# coding: utf-8
# Your code here!
import bisect
from collections import defaultdict
import sys
sys.setrecursionlimit(int(1e6))
N, K = list(map(int, input().rstrip().split(' ')))
X = sorted(list(map(int, input().rstrip().split(' '))))
i = bisect.bisect_left(X, 0)
X.insert(i, 0)
memo = defaultdict(lambda: defaultdict(lambda: -1))
def recursive(current_k, cost, i, left_i, right_i):
if K == current_k:
return cost
if memo[current_k][i] != -1:
return memo[current_k][i]
left_cost = 1e10
if left_i >= 0:
left_cost = recursive(current_k + 1, cost + X[i] - X[left_i], left_i, left_i - 1, right_i)
right_cost = 1e10
if right_i <= N:
right_cost = recursive(current_k + 1, cost + X[right_i] - X[i], right_i, left_i, right_i + 1)
min_cost = min(left_cost, right_cost)
memo[current_k][i] = min_cost
return min_cost
print((recursive(0, 0, i, i - 1, i + 1))) | # coding: utf-8
# Your code here!
N, K = list(map(int, input().rstrip().split(' ')))
X = list(map(int, input().rstrip().split(' ')))
min_cost = int(1e10)
for i in range(K, N+1):
min_cost = min(min_cost, X[i-1] - X[i-K] + min(abs(X[i-1]), abs(X[i-K])))
print(min_cost)
| p03274 |
from bisect import bisect_left
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
if 0 in x:
x.remove(0)
k -= 1
n -= 1
if n == 0:
print((0))
else:
si = bisect_left(x, 0)
ans = (x[-1] - x[0]) * 2
if si + k - 1 < len(x):
ans = min(ans, x[si + k - 1])
if si - k >= 0:
ans = min(ans, abs(x[si - k]))
for i in range(n):
tmp_ans = 0
if i < si and i + k -1 < len(x):
tmp_ans = abs(x[i]) * 2 + x[i + k - 1]
ans = min(ans, tmp_ans)
elif i >= si and i - k + 1 >= 0:
tmp_ans = x[i] * 2 + abs(x[i - k + 1])
ans = min(ans, tmp_ans)
print(ans)
| from bisect import bisect_left
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
si = bisect_left(x, 0)
ans = (x[-1] - x[0]) * 2
if si + k - 1 < len(x):
ans = min(ans, x[si + k - 1])
if si - k >= 0:
ans = min(ans, abs(x[si - k]))
for i in range(n):
tmp_ans = 0
if i < si and i + k -1 < len(x):
tmp_ans = abs(x[i]) * 2 + x[i + k - 1]
ans = min(ans, tmp_ans)
elif i >= si and i - k + 1 >= 0:
tmp_ans = x[i] * 2 + abs(x[i - k + 1])
ans = min(ans, tmp_ans)
print(ans)
| p03274 |
from bisect import bisect_left
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
si = bisect_left(x, 0)
ans = (x[-1] - x[0]) * 2
if si + k - 1 < len(x):
ans = min(ans, x[si + k - 1])
if si - k >= 0:
ans = min(ans, abs(x[si - k]))
for i in range(n):
tmp_ans = 0
if i < si and i + k -1 < len(x):
tmp_ans = abs(x[i]) * 2 + x[i + k - 1]
ans = min(ans, tmp_ans)
elif i >= si and i - k + 1 >= 0:
tmp_ans = x[i] * 2 + abs(x[i - k + 1])
ans = min(ans, tmp_ans)
print(ans)
| n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9
for i in range(n - k + 1):
cand = x[i + k - 1] - x[i] + min(abs(x[i + k - 1]), abs(x[i]))
ans = min(ans, cand)
print(ans)
| p03274 |
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**9
for i in range(n-k+1):
x2 = x[i:i+k]
if x2[0]*x2[-1] < 0:
left = 2*abs(x2[0])+abs(x2[-1])
right = 2*abs(x2[-1])+abs(x2[0])
ans= min(ans,min(left,right))
else:
ans = min(ans,max(abs(x2[0]),abs(x2[-1])))
print(ans) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**9
for i in range(n-k+1):
if x[i]*x[i+k-1] < 0:
left = 2*abs(x[i])+abs(x[i+k-1])
right = 2*abs(x[i+k-1])+abs(x[i])
ans= min(ans,min(left,right))
else:
ans = min(ans,max(abs(x[i]),abs(x[i+k-1])))
print(ans) | p03274 |
n, k = list(map(int, input().split()))
xlis = list(map(int, input().split()))
ret = 10 ** 100
for i in range(n-k+1):
cand = xlis[i:k+i]
min_val = cand[0]
max_val = cand[-1]
if min_val * max_val >= 0:
tmp = max(abs(min_val), abs(max_val))
ret = min(ret, tmp)
else:
fst = min(abs(min_val), abs(max_val))
lst = max(abs(min_val), abs(max_val))
tmp = fst * 2 + lst
ret = min(ret, tmp)
print(ret)
| n, k = list(map(int, input().split()))
xlis = list(map(int, input().split()))
ret = 10 ** 100
for i in range(n-k+1):
min_val = xlis[i]
max_val = xlis[k+i-1]
if min_val * max_val >= 0:
tmp = max(abs(min_val), abs(max_val))
ret = min(ret, tmp)
else:
fst = min(abs(min_val), abs(max_val))
lst = max(abs(min_val), abs(max_val))
tmp = fst * 2 + lst
ret = min(ret, tmp)
print(ret)
| p03274 |
import sys
input = sys.stdin.readline
def main():
_, K = list(map(int, input().split()))
X = [int(c) for c in input().split()]
def fullsearch():
for l, r in zip(X, X[K-1:]):
distance = abs(r - l)
yield distance + abs(r)
yield distance + abs(l)
print((min(fullsearch())))
main() | import sys
input = sys.stdin.readline
def main():
_, K = list(map(int, input().split()))
X = list(map(int, input().split()))
def fullsearch():
for l, r in zip(X, X[K-1:]):
distance = abs(r - l)
yield distance + abs(r)
yield distance + abs(l)
print((min(fullsearch())))
main() | p03274 |
import sys
input = sys.stdin.readline
def main():
_, K = list(map(int, input().split()))
X = list(map(int, input().split()))
def fullsearch():
for l, r in zip(X, X[K-1:]):
distance = abs(r - l)
yield distance + abs(r)
yield distance + abs(l)
print((min(fullsearch())))
main() | import sys
input = sys.stdin.readline
def fullsearch(x, k):
for l, r in zip(x, x[k-1:]):
distance = abs(r - l)
yield distance + abs(r)
yield distance + abs(l)
def main():
_, K = list(map(int, input().split()))
X = list(map(int, input().split()))
print((min(fullsearch(X, K))))
main() | p03274 |
# sys.stdin.readline()
import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
x_p = [0] + [p for p in x if p > 0]#正
x_z = x.count(0)#0
x_n = [(-1) * ng for ng in x if ng < 0]#負
x_n = [0] + sorted(x_n)#0から始まる絶対値
myK = k - x_z#左右に移動して点火するろうそく数
if myK <= 0:
print((0))
else:
ans = float('inf')
for i in range(myK + 1):
if 0 <= i < len(x_p) and 0 <= myK - i < len(x_n):
ans = min(ans, x_p[i] + x_n[myK - i] + min(x_p[i], x_n[myK - i]))
print(ans) | n , k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = float('inf')
for i in range(n - k + 1):
ans = min(
ans,
abs(x[i]) + abs(x[i + k - 1] - x[i]),
abs(x[i + k - 1]) + abs(x[i + k - 1] - x[i])
)
print(ans) | p03274 |
inf = float('inf')
N, K = list(map(int, input().split()))
x = tuple(map(int, input().split()))
m, p = [], []
for xx in x:
if xx > 0:
p.append(xx)
elif xx < 0:
m.append(-xx)
else:
K -= 1
if K == 0:
print((0))
exit()
m.sort()
lp = len(p)
lm = len(m)
ans = inf
for from_minus in range(min(lm, K) + 1):
from_plus = K - from_minus
if from_plus > lp:
continue
if from_minus == 0:
ans = min(ans, p[K - 1])
elif from_minus == K:
ans = min(ans, m[K - 1])
else:
ans = min(ans, p[from_plus - 1] * 2 + m[from_minus - 1])
ans = min(ans, m[from_minus - 1] * 2 + p[from_plus - 1])
print(ans)
| def main():
N, K = list(map(int, input().split()))
*x, = list(map(int, input().split()))
ans = 3 * 10 ** 8
for left, right in zip(x, x[K - 1:]):
if left * right < 0:
ans = min(ans, right - left + min(-left, right))
else:
ans = min(ans, -left if left < 0 else right)
print(ans)
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| p03274 |
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))+[0]
ans=10**20
for i in range(N-K+1):
x=X[i:i+K]
l,r=x[0],x[-1]
if l<=0 and r<=0:
ans=min(ans,-l)
elif l>=0 and r>=0:
ans=min(ans,r)
else:
res=min(abs(l),abs(r))*2+max(abs(l),abs(r))
ans=min(ans,res)
print(ans) | N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
ans=float('inf')
for l in range(N-K+1):
r=l+K-1
ans=min(ans,min(abs(X[l]),abs(X[r]))+X[r]-X[l])
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
d = [0 for _ in range(n)]
S = [0 for _ in range(n)]
for i in range(1, n):
d[i] = x[i] - x[i - 1]
S[i] = S[i - 1] + d[i]
tmp = [0 for _ in range(n - k + 1)]
for i in range(n - k + 1):
tmp[i] = S[i + k - 1] - S[i] + min(abs(x[i]), abs(x[i + k - 1]))
print((min(tmp)))
| n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = abs(x[-1] - x[0]) * 2
for i in range(n - k + 1):
l = x[i]
r = x[i + k - 1]
if r < 0:
ans = min(ans, -l)
elif l > 0:
ans = min(ans, r)
else:
ans = min(ans, r - l + min(-l, r))
print(ans)
| p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
right, left = [], []
for i in range(N):
if X[i] >= 0:
right.append(X[i])
else:
left.insert(0, -X[i])
right.append(0)
left.append(0)
ans = float("inf")
for i in range(K + 1):
if len(right) < K - i + 1 or len(left) < i + 1: continue
tmp = min(2 * left[i - 1] + right[(K - i) - 1], left[i - 1] + 2 * right[(K - i) - 1])
ans = min(ans, tmp)
print(ans) | N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float("inf")
for i in range(0, N - K + 1):
ans = min(ans, min(abs(X[i]) + abs(X[i] - X[i + K - 1]), abs(X[i + K - 1]) + abs(X[i] - X[i + K - 1])))
print(ans) | p03274 |
"""
0からLまで行き、LからRまで行く = abs(L) + (R-L)
0からRまで行き、RからLまで行く = abs(R) + (R-L)
"""
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 1<<60
for i in range(0, N-K+1):
left = A[i]
right = A[i+K-1]
ans = min(ans, min(abs(left), abs(right)) + right - left)
print(ans) |
def resolve():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 1 << 60
for i in range(N - K + 1):
l = A[i]
r = A[i + K - 1]
l_to_r = abs(l) + abs(l - r)
r_to_l = abs(r) + abs(r - l)
res = min(l_to_r, r_to_l)
ans = min(ans, res)
print(ans)
if __name__ == "__main__":
resolve()
| p03274 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
A = LIST()
ans = INF
for i in range(K):
if i+K > N:
break
A2 = A[i:i+K]
l = A2[0]
r = A2[-1]
# 左だけ行く
if r <= 0:
ans = min(ans, -l)
# 右だけ行く
elif l >= 0:
ans = min(ans, r)
# 両方行く
else:
# 短い方を先に行って往復
ans = min(ans, min(-l, r) * 2 + max(-l, r))
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def check(l, r):
# 左だけ行く
if r <= 0:
return -l
# 右だけ行く
elif l >= 0:
return r
# 両方行く
else:
# 短い方を先に行って往復
return min(-l, r) * 2 + max(-l, r)
N, K = MAP()
A = LIST()
ans = INF
for i in range(N):
if i+K > N:
break
l = A[i]
r = A[i+K-1]
ans = min(ans, check(l, r))
print(ans)
| p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
answer = 10 ** 9
for i in range(N-K+1):
b, c = X[i], X[i+K-1]
if b * c >= 0:
answer = min(answer, max(abs(b), abs(c)))
else:
d, e = min(abs(b), abs(c)), max(abs(b), abs(c))
answer = min(answer, d*2+e)
print(answer)
| N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
answer = []
for i in range(N-K+1):
a, b = X[i], X[i+K-1]
answer.append(min(abs(a-b) + abs(b), abs(b-a) + abs(a)))
print((min(answer)))
| p03274 |
# coding: utf-8
import sys
from bisect import bisect_left, bisect_right
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, K = lr()
X = lr()
if 0 in X:
K -= 1
i = bisect_left(X, 0)
ne = X[:i]
i = bisect_right(X, 0)
po = X[i:]
INF = 10 ** 10
neg = [INF] * (K+1) # 左からK本選ぶ場合、K-1本選ぶ場合・・・0本選ぶ場合
neg[-1] = 0
pos = [INF] * (K+1)
pos[0] = 0
for j in range(len(ne)):
if -j-2 < -K-1:
break
neg[-j-2] = ne[-j-1]
for j in range(len(po)):
if j+1 > K:
break
pos[j+1] = po[j]
answer = INF
for j in range(K+1):
x = abs(neg[j]); y = abs(pos[j])
mi = min(x, y)
ma = max(x, y)
temp = mi * 2 + ma
if temp < answer:
answer = temp
print(answer)
# 52 | # 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()
X = lr()
answer = []
for i in range(N-K+1):
l = X[i]; r = X[i+K-1]
a = abs(l) + abs(r-l)
b = abs(r) + abs(l-r)
answer.append(min(a, b))
print((min(answer)))
# 03 | p03274 |
N, K = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
mi = 1e10
for l in range(N - K + 1):
r = l + K - 1
mi = min(mi, abs(X[l]) + abs(X[r] - X[l]), abs(X[r]) + abs(X[r] - X[l]))
print(mi) | N, K = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
print((min(r - l + min(abs(l), abs(r)) for l, r in zip(X, X[K - 1:]))))
| p03274 |
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
flag = True
for i in range(n+1):
if i == n or x[i] > 0:
x.insert(i,0)
zahyou = i
break
ans = 10**18
for i in range(k+1):
mainasu = 0
purasu = 0
flag = True
for j in range(k):
a = zahyou-k+i+j
if a >= 0 and a < n:
if x[a] < 0:
mainasu += x[a+1]-x[a]
else:
purasu += x[a+1]-x[a]
else:
flag = False
if mainasu != 0 and purasu != 0:
purasu += min(mainasu,purasu)
if flag:
ans = min(ans,mainasu+purasu)
print(ans) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
flag = True
for i in range(n+1):
if i == n or x[i] > 0:
x.insert(i,0)
zahyou = i
break
ans = 10**18
for i in range(k+1):
flag = True
if zahyou + i < n+1 and zahyou -k+i >= 0:
mainasu = x[zahyou]-x[zahyou-k+i]
purasu = x[zahyou+i]-x[zahyou]
if mainasu != 0 and purasu != 0:
purasu += min(mainasu,purasu)
ans = min(ans,mainasu+purasu)
print(ans)
| p03274 |
N,K = list(map(int,input().split()))
x = list(map(int,input().split()))
cand = []
for i in range(N-K+1):
cand.append(x[i:i+K])
ans = float('inf')
for i in range(len(cand)):
l = cand[i][0]
r = cand[i][-1]
temp = min(abs(l)+abs(r-l),abs(r)+abs(l-r))
ans = min(temp,ans)
print(ans) | N,K = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float('inf')
for i in range(N-K+1):
l = x[i]
r = x[i+K-1]
temp = min(abs(l)+abs(r-l),abs(r)+abs(l-r))
ans = min(temp,ans)
print(ans) | p03274 |
import bisect
N, K = list(map(int,input().split()))
X = list(map(int,input().split()))
s = bisect.bisect_left(X,0)
if 0 in X:
K -= 1
else:
bisect.insort_left(X,0)
N += 1
MIN = 2 * 10**9
for i in range(K+1):
if s - K + i >= 0 and s + i <N:
f = X[s -K+i]
l = X[s+i]
if abs(f) < abs(l):
ans = abs(f) * 2 + abs(l)
else:
ans = abs(l) * 2 + abs(f)
MIN =min(MIN,ans)
print(MIN) | def main():
n,k = list(map(int,input().split()))
X = list(map(int,input().split()))
ans = 10**9
for i in range(n-k+1):
t1 = abs(X[i]) + abs(X[i] - X[i+k-1])
t2 = abs(X[i+k-1]) + abs(X[i] - X[i+k-1])
t = min(t1,t2)
ans = min(ans,t)
print(ans)
main() | p03274 |
import bisect
N, K = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**9
zero = bisect.bisect_left(x, 0)
if zero == 0:
print((x[K-1]))
exit(0)
if zero+K <= N:
ans = min(ans, x[zero+K-1])
if zero >= K:
ans = min(ans, -x[zero-K])
if zero != N:
for k in range(K-1):
if 0 <= K+zero-k-2 < N and 0 <= zero-k-1 < N:
ans = min(ans,2*x[K+zero-k-2]-x[zero-k-1],x[K+zero-k-2]-2*x[zero-k-1])
print(ans)
| import bisect
N, K = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float("inf")
if x[0]*x[-1] >= 0:
if x[0] >= 0:
ans = x[K-1]
else:
ans = -x[-K]
print(ans)
else:
M = []
P = []
for e in x:
if e > 0:
P.append(e)
else:
M.append(-e)
M.sort()
M = [0] + M
P = [0] + P
for k in range(max(len(P),len(M))):
if k < len(P) and 0 <= K-k < len(M):
# print(M[K-k],P[k])
ans = min(ans,2*M[K-k]+P[k],M[K-k]+2*P[k])
print(ans)
| p03274 |
import sys
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
if __name__ == "__main__":
n, k = LI()
X = LI()
l_count = sum((x <= 0 for x in X))
r_count = n - l_count
if l_count == 0:
print((X[k-1]))
elif r_count == 0:
print((abs(X[-k])))
else:
times = []
for i in range(l_count):
try:
left = X[l_count - i - 1]
right = X[l_count + k - i - 2]
times.append(abs(2 * left) + abs(right))
times.append(abs(left) + abs(2 * right))
except:
continue
print((min(times)))
| n, k, *x = list(map(int, open(0).read().split()))
print((min([min(abs(x[i]), abs(x[i+k-1])) + (x[i+k-1] - x[i]) for i in range(n-k+1)]))) | p03274 |
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
# import fractions
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, K = il()
X = il()
ret = MAX
for n in range(N - K + 1):
C = X[n:n + K]
ret = min(ret, abs(X[n]) + abs(X[n] - X[n+K-1]), abs(X[n+K-1]) + abs(X[n] - X[n+K-1]))
print(ret)
if __name__ == '__main__':
main()
| import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
# import fractions
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N, K = il()
X = il()
ret = MAX
for n in range(N - K + 1):
ret = min(ret, abs(X[n]) + abs(X[n] - X[n+K-1]), abs(X[n+K-1]) + abs(X[n] - X[n+K-1]))
print(ret)
if __name__ == '__main__':
main()
| p03274 |
#!/usr/bin/env python3
import sys
def solve(N: int, K: int, x: "List[int]"):
def search_naive(cur, k, x):
if k == K:
return 0
costs = []
for i in range(len(x)):
xi = x[i]
dist = abs(xi-cur)
costs.append(dist + search_naive(xi, k+1, x[:i]+x[i+1:]))
return min(costs)
print((search_naive(0, 0, x)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, K, x)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, K: int, x: "List[int]"):
def search_naive(cur, k, x):
if k == K:
return 0
costs = []
for i in range(len(x)):
xi = x[i]
dist = abs(xi-cur)
costs.append(dist + search_naive(xi, k+1, x[:i]+x[i+1:]))
return min(costs)
def search(N, window_size, x):
costs = []
for i in range(N-window_size+1):
conds = x[i:i+window_size]
right_end = max([x for x in conds if x>=0], default=0)
left_end = abs(min([x for x in conds if x<0], default=0))
if right_end > left_end:
costs.append(right_end + 2*left_end)
else:
costs.append(2*right_end + left_end)
return min(costs)
#print(search_naive(0, 0, x))
print((search(N, K, x)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, K, x)
if __name__ == '__main__':
main()
| p03274 |
#!/usr/bin/env python3
import sys
def solve(N: int, K: int, x: "List[int]"):
def search_naive(cur, k, x):
if k == K:
return 0
costs = []
for i in range(len(x)):
xi = x[i]
dist = abs(xi-cur)
costs.append(dist + search_naive(xi, k+1, x[:i]+x[i+1:]))
return min(costs)
def search(N, window_size, x):
costs = []
for i in range(N-window_size+1):
conds = x[i:i+window_size]
right_end = max([x for x in conds if x>=0], default=0)
left_end = abs(min([x for x in conds if x<0], default=0))
if right_end > left_end:
costs.append(right_end + 2*left_end)
else:
costs.append(2*right_end + left_end)
return min(costs)
#print(search_naive(0, 0, x))
print((search(N, K, x)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, K, x)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, K: int, x: "List[int]"):
def search(N, window_size, x):
costs = []
for i in range(N-window_size+1):
right_end = x[i+window_size-1]
left_end = x[i]
dist = abs(right_end-left_end)
costs.append(min(abs(right_end)+dist, abs(left_end)+dist))
return min(costs)
print((search(N, K, x)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
x = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, K, x)
if __name__ == '__main__':
main()
| p03274 |
N,K=list(map(int,input().split()))
x=[int(i) for i in input().split()]
cost=[]
for i in range(N-K+1):
length=0
for j in range(K-1):
length+=abs(x[i+j+1]-x[i+j])
cost.append(length+abs(x[i]))
cost.append(length+abs(x[i+K-1]))
print((min(cost))) | N,K=list(map(int,input().split()))
x=[int(i) for i in input().split()]
cost=[]
for i in range(N-K+1):
length=abs(x[i]-x[i+K-1])
cost.append(length+abs(x[i]))
cost.append(length+abs(x[i+K-1]))
print((min(cost))) | p03274 |
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
res = 10**10
for i in range(n-k+1):
kx = x[i:i+k]
l=kx[0]
r = kx[-1]
lrsmall = min(abs(l),abs(r))
res = min(r-l+lrsmall,res)
print(res) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
kx = x[0:k]
l=kx[0]
r = kx[-1]
lrsmall = min(abs(l),abs(r))
res = r-l+lrsmall
for i in range(1,n-k+1):
del kx[0]
kx.append(x[i+k-1])
l=kx[0]
r = kx[-1]
lrsmall = min(abs(l),abs(r))
res = min(r-l+lrsmall,res)
print(res) | p03274 |
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
kx = x[0:k]
l=kx[0]
r = kx[-1]
lrsmall = min(abs(l),abs(r))
res = r-l+lrsmall
for i in range(1,n-k+1):
del kx[0]
kx.append(x[i+k-1])
l=kx[0]
r = kx[-1]
lrsmall = min(abs(l),abs(r))
res = min(r-l+lrsmall,res)
print(res) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
res = 10**10
for i in range(0,n-k+1):
l = x[i]
r = x[i+k-1]
lrsmall = min(abs(l),abs(r))
res = min(r-l+lrsmall,res)
print(res) | p03274 |
n,k = list(map(int,input().split()))
lst = [int(i) for i in input().split()]
for i in range(n-k+1):
l = lst[i]
r = lst[i+k-1]
way1 = abs(l) + abs(r-l)
way2 = abs(r) + abs(l-r)
m = min(way1,way2)
if i==0:
ans = m
elif m < ans:
ans = m
print(ans) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float('inf')
for i in range(n-k+1):
l = x[i]
r = x[i+k-1]
w1 = abs(l)+abs(r-l)
w2 = abs(r)+abs(l-r)
ans = min(ans, min(w1,w2))
print(ans) | p03274 |
from itertools import combinations
N,K=list(map(int,input().split()))
X = list(map(int, input().split()))
print((min([min(abs(cmb[0]) + abs(cmb[-1]-cmb[0]), abs(cmb[-1]) + abs(cmb[0]-cmb[-1])) for cmb in combinations(X,K)]))) | N,K=list(map(int,input().split()))
X = list(map(int, input().split()))
print((min([min(abs(X[i]) + abs(X[i+K-1]-X[i]), abs(X[i+K-1]) + abs(X[i]-X[i+K-1])) for i in range(N-K+1)]))) | p03274 |
N,K=list(map(int,input().split()))
X = list(map(int, input().split()))
print((min([min(abs(X[i]) + abs(X[i+K-1]-X[i]), abs(X[i+K-1]) + abs(X[i]-X[i+K-1])) for i in range(N-K+1)]))) | N, K = list(map(int, input().split()))
posX = []
negX = []
for x in map(int, input().split()):
if 0 <= x:
posX.append(x)
else:
negX.append(-x)
negX.sort()
len_posX = len(posX)
len_negX = len(negX)
ans = float('inf')
for pos_k in range(len_posX + 1):
neg_k = K - pos_k
if len_negX <= neg_k - 1:
continue
if neg_k == 0 and len_posX != 0:
ans = min(ans, posX[pos_k - 1])
elif pos_k == 0 and len_negX != 0:
ans = min(ans, negX[neg_k - 1])
elif len_posX != 0 and len_negX != 0:
ans = min(ans, posX[pos_k - 1] + 2 * negX[neg_k - 1], 2 * posX[pos_k - 1] + negX[neg_k - 1])
print(ans)
| p03274 |
# -*- coding:utf-8 -*-
import copy
INF = 2*(10**8)+1
memo = INF # メモ化用変数
def solve():
N, K = list(map(int, input().split(" ")))
X = [0]
X.extend(list(map(int, input().split(" "))))
X.sort()
# 幅優先探索すればいいんじゃね？
def dfs(depth, cost, i, Xs):
global memo
if depth == K:
memo = min(cost, memo)
return cost
if cost >= memo:
# 探索を打ち切る
return INF
ret1, ret2 = INF, INF
if i+1 < len(Xs):
# 右に移動
tmpCost = abs(Xs[i] - Xs[i+1])
tmpXs = copy.deepcopy(Xs)
del tmpXs[i]
ret1 = dfs(depth+1, cost+tmpCost, i, tmpXs)
if i-1 >= 0:
# 左に移動
tmpCost = abs(Xs[i] - Xs[i-1])
tmpXs = copy.deepcopy(Xs)
del tmpXs[i]
ret2 = dfs(depth+1, cost+tmpCost, i-1, tmpXs)
return min(ret1, ret2)
# 0座標のインデックスは？
for i in range(len(X)):
if X[i] == 0:
break
ans = dfs(0, 0, i, X)
print(ans)
if __name__ == "__main__":
solve() | # -*- coding:utf-8 -*-
"""解説
https://www.youtube.com/watch?v=5O4k1n5Ejzw
区間を考える問題
-30 -10 0 10 20 50
・K = 3のとき、
0座標を必ず含める、ある連続するK個のロウソクについて考える
・-30 -10 0 10
・-10 0 10 20
・0 10 20 50
左端と右端に到達する最小値を求めていけばよくて、間のロウソクは無視してよい（必ず移動中に火をつけるので）
すべての場合について求めて、その中の最小値が答え
"""
def solve():
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
if 0 in X:
# 0座標にロウソクがあるなら、火をつけるロウソクをひとつ減らしてよい
K -= 1
else:
X.append(0)
X.sort()
origin_i = X.index(0)
left_i = max(origin_i-K, 0)
INF = 10**12
ans = INF
while left_i <= origin_i:
if left_i+K < len(X):
tmp1 = abs(X[left_i]-0)*2 + abs(X[left_i+K]-0)
tmp2 = abs(X[left_i]-0) + abs(X[left_i+K]-0)*2
else:
break
ans = min(ans, tmp1, tmp2)
left_i += 1
print(ans)
if __name__ == "__main__":
solve()
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
neg_num = n
for i in range(n):
if x[i] > 0:
neg_num = i
break
pos_num = n - neg_num
l = min(k, neg_num)
res = 10 ** 13
for i in range(l, -1, -1):
r = k - i
if r <= pos_num:
l_val = min(0, x[neg_num - i])
r_val = max(0, x[neg_num + k - i - 1])
tmp = min( -l_val * 2 + r_val, -l_val + r_val * 2)
res = min(tmp, res)
print(res) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
neg_to_pos = n
for i in range(n):
if x[i] > 0:
neg_to_pos = i
break
res = 10 ** 14
for i in range(n - k + 1):
l = min(x[i], 0)
r = max(0, x[i + k - 1])
if i <= neg_to_pos and neg_to_pos - 1 <= i + k - 1:
tmp = min(-2 * l + r, -l + 2 * r)
res = min(res, tmp)
print(res) | p03274 |
import bisect
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
t = 2 * (x[-1] - x[0])
i = bisect.bisect_right(x, 0)
for j in range(0, N):
if N <= j + K -1 :
break
if (j - (i - 0.1)) * (j + K- 1 - (i - 0.1)) >= 0:
t = min(t, max(abs(x[j]), abs(x[j+K-1])))
else:
t = min(t, abs(2 * x[j]) + x[j+K-1])
t = min(t, abs(x[j]) + 2 * x[j+K-1])
print(t) | N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dist = 2 * (x[-1] - x[0])
for i in range(N):
if i + K -1 >= N:
break
dist = min(dist, abs(x[i]) + abs(x[i + K - 1] - x[i]),abs(x[i + K -1]) + abs(x[i + K - 1] - x[i]))
print(dist) | p03274 |
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, string, copy
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
mod = 10**9+7
ans = inf
count = 0; pro = 1
n, k = list(map(int, input().split()))
A=[]; B=[]
x=list(map(int,input().split()))
for i in range(n-(k-1)):
candi = max(abs(x[i+k-1]),abs(x[i]))
if x[i+k-1]*x[i]<0:
candi += 2*min(abs(x[i+k-1]), abs(x[i]))
ans = min(ans, candi)
print(ans)
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,k = list(map(int,input().split()))
X = list(map(int,input().split()))
for i in range(n-k+1):
fi = X[i]
en = X[i+k-1]
if fi <= 0 and en >= 0:
mans = min(mans,min(-fi,en)-fi+en)
else:
mans=min(mans,max(abs(fi),abs(en)))
print(mans) | p03274 |
N, K = list(map(int, input().split()))
x = list(map(int,input().split()))
candidate = []
for i in range(N - K + 1):
tmp = []
for j in range(i, i + K):
tmp.append(x[j])
candidate.append(tmp)
ans = 1000000000
for i in candidate:
tmp = 0
#最初の要素がマイナスだとマイナスとプラスの混合の可能性がある
if i[0] < 0:
#混合の場合
if i[-1] > 0:
#マイナスに最後に行く場合
if abs(i[0]) > abs(i[-1]):
tmp += abs(i[-1]) * 2
tmp += abs(i[0])
#プラスに最後に行く場合
else:
tmp += abs(i[0]) * 2
tmp += abs(i[-1])
#混合じゃない
else:
tmp += abs(i[0])
else:
#単純にすべて足す。
tmp += i[-1]
ans = min(ans, tmp)
print(ans)
| N, K = list(map(int, input().split()))
x = list(map(int,input().split()))
ans = 100000000000
#最初と最後だけ調べればOK
for i in range(N - K + 1):
tmp_min = x[i]
tmp_max = x[i + K - 1]
tmp = 0
if tmp_min < 0:
#混合の場合
if tmp_max > 0:
#+に先に行く場合
if abs(tmp_min) > tmp_max:
tmp = tmp_max * 2
tmp += abs(tmp_min)
#-に先に行く場合
else:
tmp = abs(tmp_min) * 2
tmp += tmp_max
#すべてマイナスの場合
else:
tmp = abs(tmp_min)
else:
tmp = tmp_max
ans = min(ans, tmp)
print(ans)
| p03274 |
N, K = list(map(int, input().split()))
x = list(map(int,input().split()))
ans = 100000000000
#最初と最後だけ調べればOK
for i in range(N - K + 1):
tmp_min = x[i]
tmp_max = x[i + K - 1]
tmp = abs(tmp_min) + abs(tmp_min - tmp_max)
tmp2 = abs(tmp_max) + abs(tmp_min - tmp_max)
ans = min(ans, min(tmp, tmp2))
print(ans)
| N, K = list(map(int, input().split()))
x = list(map(int,input().split()))
ans = 100000000000
#最初と最後だけ調べればOK
for i in range(N - K + 1):
tmp_min = x[i]
tmp_max = x[i + K - 1]
ans = min(ans, min(abs(tmp_min), abs(tmp_max)) + abs(tmp_min - tmp_max))
print(ans)
| p03274 |
#-*-coding:utf-8-*-
def main():
n, k = list(map(int, input().split()))
x_list = list(map(int, input().split()))
ans = float('inf')
for i in range(n - k + 1):
arry = x_list[i:i+k]
if arry[0] >= 0 and arry[-1] >= 0:
ans = min(ans, arry[-1])
elif arry[0] < 0 and arry[-1] < 0:
ans = min(ans, -arry[0])
else:
ans = min(ans, -arry[0] * 2 + arry[-1])
print(ans)
if __name__ == '__main__':
main() | #-*-coding:utf-8-*-
def main():
n, k = list(map(int, input().split()))
x_list = list(map(int, input().split()))
ans = float('inf')
for i in range(n - k + 1):
if x_list[i] >= 0 and x_list[i+k-1] >= 0:
ans = min(ans, x_list[i+k-1])
elif x_list[i] <= 0 and x_list[i+k-1] <= 0:
ans = min(ans, -x_list[i])
else:
ans = min(ans, min(-x_list[i] * 2 + x_list[i+k-1] , -x_list[i] + x_list[i+k-1] * 2))
print(ans)
if __name__ == '__main__':
main() | p03274 |
import bisect
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
for distance in range(100000000):
a = bisect.bisect_left(x, -distance)
b = bisect.bisect_right(x, distance)
near_k = b- a
if near_k == k:
break
elif near_k > k:
if x[a]+1 in x:
a += 1
break
elif x[b-1] - 1 in x:
b -= 1
break
if x[b-1] * x[a] < 0:
semi_final_distance = max(x[b-1], x[a])+ (-2 * min(x[b-1], x[a]))
else:
semi_final_distance = max(x[b-1], x[a])
a_2 = bisect.bisect_left(x, -semi_final_distance)
b_2 = bisect.bisect_right(x, semi_final_distance)
c = bisect.bisect_left(x, 0)
if b_2 - c > k:
for distance in range(semi_final_distance):
b_3 = bisect.bisect_right(x, distance)
if b_3 - c == k:
print(distance)
exit()
elif c - a_2 > k:
for distance in range(semi_final_distance):
a_3 = bisect.bisect_left(x, -distance)
if c - a_3 == k:
print(distance)
exit()
else:
print(semi_final_distance)
| n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
num = 1000000000
def cal_num(a, b):
if x[a] * x[b] < 0:
return min(abs(x[a]), abs(x[b])) * 2 + max(abs(x[a]), abs(x[b]))
else:
return max(abs(x[a]), abs(x[b]))
for i in range(n-k+1):
c = cal_num(i, i+k-1)
if num >= c:
num = c
print(num)
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10 ** 9
for i in range(n-k+1):
temp = x[i:i+k]
dif = temp[-1] - temp[0]
from_s = min(abs(temp[-1]), abs(temp[0]))
ans = min(dif + from_s, ans)
print(ans) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10 ** 9
for i in range(n-k+1):
l = abs(x[i]) + abs(x[i+k-1] - x[i])
r = abs(x[i+k-1]) + abs(x[i+k-1] - x[i])
if l < r:
ans = min(ans, l)
else:
ans = min(ans, r)
print(ans) | p03274 |
# vim: set fileencoding=utf-8:
import bisect
def main():
N, K = list(map(int, input().split()))
x = [int(ele) for ele in input().split()]
o = bisect.bisect_right(x, 0)
top = min(o + K, N)
bottom = max(o - K, 0)
x = x[bottom:top]
best = 999999999999
u = len(x)
for i in range(u):
if u < i + K:
break
hani = x[i:i + K]
if hani[0] < 0 and hani[-1] < 0:
best = min(best, abs(hani[0]))
elif hani[0] < 0 <= hani[-1]:
best = min(best, 2 * abs(hani[0]) + hani[-1])
elif 0 <= hani[0] and 0 <= hani[-1]:
best = min(best, hani[-1])
print(best)
if __name__ == "__main__":
main()
| # vim: set fileencoding=utf-8:
import bisect
def main():
N, K = list(map(int, input().split()))
x = [int(ele) for ele in input().split()]
o = bisect.bisect_right(x, 0)
top = min(o + K, N)
bottom = max(o - K, 0)
best = 999999999999
for i in range(K):
if top < bottom + i + K:
break
if x[bottom + i + K - 1] < 0:
best = min(best, abs(x[bottom + i]))
elif x[bottom + i] < 0 <= x[bottom + i + K - 1]:
ans1 = 2 * min(abs(x[bottom + i]), x[bottom + i + K - 1])
ans2 = max(abs(x[bottom + i]), x[bottom + i + K - 1])
ans = min(best, ans1 + ans2)
best = min(best, ans)
elif 0 <= x[bottom + i]:
best = min(best, x[bottom + i + K - 1])
print(best)
if __name__ == "__main__":
main()
| p03274 |
MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 <= xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N):
if N - 1 < i + K - 1:
break
if xn[i] < 0:
if xn[i + K - 1] < 0 and i + K <= N - 1 and 0 < xn[i + K]:
ans = min(ans, abs(xn[i]))
elif 0 <= xn[i + K - 1]:
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
elif 0 == xn[i]:
ans = min(ans, xn[i + K - 1])
print(ans)
return
main()
| MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 <= xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
if xn[i + K - 1] < 0 and i + K <= N - 1 and 0 < xn[i + K]:
ans = min(ans, abs(xn[i]))
elif 0 <= xn[i + K - 1]:
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| p03274 |
MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 <= xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
if xn[i + K - 1] < 0 and i + K <= N - 1 and 0 < xn[i + K]:
ans = min(ans, abs(xn[i]))
elif 0 <= xn[i + K - 1]:
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 <= xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| p03274 |
MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 <= xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 < xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| p03274 |
MAX = 300000001
N, K = list(map(int, input().split()))
xn = [int(i) for i in input().split()]
def main():
if 0 < xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX
for i in range(N - K + 1):
if xn[i + K - 1] < 0 and i + K <= N - 1 and 0 < xn[i + K]:
ans = min(ans, abs(xn[i]))
elif 0 < xn[i]:
if 0 != i:
if xn[i - 1] < 0:
ans = min(ans, abs(xn[i + K - 1]))
else:
break
elif 0 <= xn[i + K - 1]:
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| MAX_D = 300000001
def main():
N, K, *xn = list(map(int, open(0).read().split()))
if 0 < xn[0]:
print((xn[K - 1]))
return
if xn[N - 1] < 0:
print((abs(xn[N - K])))
return
ans = MAX_D
for i in range(N - K + 1):
if xn[i + K - 1] < 0 and i + K <= N - 1 and 0 < xn[i + K]:
ans = min(ans, abs(xn[i]))
elif 0 < xn[i]:
if 0 != i:
if xn[i - 1] < 0:
ans = min(ans, abs(xn[i + K - 1]))
else:
break
elif 0 <= xn[i + K - 1]:
ans = min(ans,
2 * abs(xn[i]) + abs(xn[i + K - 1]),
abs(xn[i]) + 2 * abs(xn[i + K - 1]))
print(ans)
return
main()
| p03274 |
# coding: utf-8
# Your code here!
import bisect
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
zero=bisect.bisect_left(X,0)
ans=10**18
start=max(0,zero-K)
for i in range(start,start+N-K+1):
temp=X[i:i+K]
m=min(0,min(temp))
M=max(0,max(temp))
ans=min((abs(m)+abs(M)*2),(abs(m)*2+abs(M)),ans)
print(ans)
| # coding: utf-8
# Your code here!
import bisect
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
zero=bisect.bisect_left(X,0)
ans=10**18
start=max(0,zero-K)
for i in range(start,start+N-K+1):
#print(i)
m=min(0,X[i])
M=max(0,X[i+K-1])
ans=min((abs(m)+abs(M)*2),(abs(m)*2+abs(M)),ans)
if i+K==N:
break
print(ans)
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10 ** 10
for i in range(n - k + 1):
temp = x[i:i + k]
left = temp[0]
right = temp[-1]
ans = min(ans, abs(left) + abs(right - left), abs(right) + abs(right - left))
print(ans)
| n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10 ** 10
for i in range(n - k + 1):
left = x[i]
right = x[i + k - 1]
ans = min(ans, abs(left) + abs(right - left), abs(right) + abs(right - left))
print(ans)
| p03274 |
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
P = [0] + [abs(i) for i in A if i> 0 ]
M = [abs(i) for i in A if i< 0 ] +[0]
M = sorted(M,reverse =False)
cnt = 10000000000
if len(P) == len(M) == 1:
cnt = 0
elif len(P) == 1:
cnt = M[K]
elif len(M) == 1:
cnt = P[K]
else:
#リストがK以下の場合不具合が起きる
#for i in range(1,K):
#len(P)=4 len(M)=3 K=5の場合、IndexErrorとなる。rangeをうまく設定する必要があるが実装できない。
#正の方向でi個ろうそくを通って、負の方向にK-i個ろうそくを通る
s = max(0,K-len(M)+1)
e = min(K+1, len(P))
for i in range(s, e):
cnt =min(cnt,P[i]*2 + M[K-i])
#負の方向でi個ろうそくを通って、正の方向にK-i個ろうそくを通る
s1 = max(0,K-len(P)+1)
e1 = min(K+1, len(M))
for i in range(s1, e1):
cnt =min(cnt,M[i]*2 + P[K-i])
print(cnt) | N,K = list(map(int,input().split()))
X = list(map(int,input().split()))
ans = 10**10
for i in range(N-K+1):
#S = X[i:i+K]
#print(S,S[0],S[-1])
mi = X[i]
ma = X[i+K-1]
#print(mi,ma)
if ma<=0:
ans = min(ans ,abs(mi))
elif mi>0:
ans = min(ans ,ma)
elif mi<0 and ma>0:
if abs(mi) > ma :
ans = min(ans,abs(mi) + 2*ma)
else :
ans = min(ans,abs(mi)*2 + ma)
print(ans) | p03274 |
n, k = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = float('Inf')
for i in range(n-k+1):
temp = c[i:i+k]
l, r = abs(temp[0]), abs(temp[-1])
if temp[0] < 0 and temp[-1] > 0:
ans = min(ans, min(l, r) * 2 + max(l, r))
else:
ans = min(ans, max(list(map(abs, temp))))
print(ans) | n, k = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = float('Inf')
for i in range(n-k+1):
l, r = c[i], c[i+k-1]
ans = min(abs(l) + abs(r-l), abs(r) + abs(r-l), ans)
print(ans) | p03274 |
import sys
import math # noqa
import bisect # noqa
import queue # noqa
def input():
return sys.stdin.readline().rstrip()
def solve(X, K):
N = len(X)
cumsum = [0 for _ in range(N)]
for i in range(1, N):
cumsum[i] = abs(X[i] - X[i - 1]) + cumsum[i - 1]
idx_zero = bisect.bisect_left(X, 0)
ret = 1000000005
for i in range(0, N):
if X[i] >= 0:
break
res = -X[i]
k = idx_zero - i
if (k < K) and (idx_zero + K - k - 1 < N):
res += cumsum[idx_zero + K - k - 1] - cumsum[i]
ret = min(ret, res)
return ret
if __name__ == '__main__':
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
res = 1000000005
if min(X) >= 0:
print((X[K - 1]))
elif max(X) <= 0:
X = X[::-1]
print((-X[K - 1]))
else:
res = min(res, solve(X, K))
X = [-x for x in X]
res = min(res, solve(X[::-1], K))
print(res)
| n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
minus = []
plus = []
ans = 10**100
for x in a:
if x <0:minus.append(-x)
else:plus.append(x)
minus = minus[::-1]
for i in range(min(k+1,len(minus)+1)):#負のものをi個通る
if k-i > len(plus):continue
res = 0
if i-1 >=0:res += minus[i-1]
res*=2
if k-i-1 >=0 and k-i <= len(plus):res += plus[k-i-1]
ans = min(ans,res)
res = 0
if k-i-1 >=0 and k-i <= len(plus):res += plus[k-i-1]
res *=2
if i-1 >=0:res += minus[i-1]
ans = min(ans,res)
print(ans)
| p03274 |
import itertools
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
pos = [0]
neg = []
for i in x:
if i<0:
neg.append(-i)
else:
pos.append(i)
neg = [0] + neg[::-1]
# negを往復する場合
neg_twice = []
for i in range(min(len(neg),k)):
neg_twice.append(neg[i]*2)
for i in range(len(neg_twice)):
if k-i<len(pos):
neg_twice[i] += pos[k-i]
else:
neg_twice[i] = float('inf')
# posを往復する場合
pos_twice = []
for i in range(min(len(pos),k)):
pos_twice.append(pos[i]*2)
for i in range(len(pos_twice)):
if k-i<len(neg):
pos_twice[i] += neg[k-i]
else:
pos_twice[i] = float('inf')
print((min(pos_twice+neg_twice)))
| n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
pos = []
neg = []
for i in x:
if i < 0:
neg.append(-i)
else:
pos.append(i)
neg = neg[::-1]
pos = [0] + pos
neg = [0] + neg
#print(pos)
#print(neg)
# posにいってからneg
res = float('inf')
for i in range(min(len(pos),k)):
# posからi本灯して, negからK-i本灯す
j = k - i
if j >= len(neg):
continue
tmp = pos[i] * 2 + neg[j]
res = min(res, tmp)
# negにいってからpos
for i in range(min(len(neg),k)):
j = k - i
if j >= len(pos):
continue
tmp = neg[i] * 2 + pos[j]
res = min(res, tmp)
print(res)
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
min_t = 10 ** 9
import bisect
snuke = bisect.bisect_left(x, 0)
if snuke < n and x[snuke] == 0:
k -= 1
n -= 1
del x[snuke]
for i in range(k+1):
if i == 0:
left = 0
elif snuke - i >= 0:
left = abs(x[snuke - i])
else:
left = 10 ** 9
if k - i == 0:
right = 0
elif snuke + k - i - 1 <= n - 1:
right = abs(x[snuke + k - i - 1])
else:
right = 10 ** 9
min_t = min(min_t, min(left, right) * 2 + max(left, right))
print(min_t) | n,k=list(map(int,input().split()))
x=sorted(list(map(int,input().split())))
a=[]
for i in range(n-k+1):
l=x[i]
r=x[i+k-1]
a.append(min(abs(l)+abs(r-l),abs(r)+abs(l-r)))
print((min(a))) | p03274 |
N, K = list(map(int, input().split()))
candles = list(map(int, input().split()))
abs_c = [abs(c) for c in candles]
result = []
for n in range(N-K+1):
route = candles[n:n+K]
r1 = abs(route[0]) + abs(route[-1]-route[0])
r2 = abs(route[-1]) + abs(route[0]-route[-1])
result.append(min(r1, r2))
print((min(result))) | N, K = list(map(int, input().split()))
candles = list(map(int, input().split()))
abs_c = [abs(c) for c in candles]
result = []
for n in range(N-K+1):
r1 = abs(candles[n]) + abs(candles[n+K-1]-candles[n])
r2 = abs(candles[n+K-1]) + abs(candles[n]-candles[n+K-1])
result.append(min(r1, r2))
print((min(result)))
| p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
left = []
right = []
cnt = 0
for i in range(N):
if x[i] < 0:
left += [-x[i]]
elif x[i] > 0:
right += [x[i]]
else:
cnt += 1
rest = K - cnt
left = left[::-1]
if rest != 0:
ans = float('inf')
else:
ans = 0
print(ans)
exit()
for i in range(rest+1):
if i == 0 and len(right) >= rest:
ans = min(ans, right[rest-1])
elif rest-i == 0 and len(left) >= i:
ans = min(ans, left[rest-1])
elif len(left) >= i and len(right) >= rest-i:
ans = min(ans, left[i-1]+right[rest-i-1]+min(left[i-1], right[rest-i-1]))
print(ans) | N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = float('inf')
for i in range(N-K+1):
ans = min(ans, abs(x[i]) + abs(x[i]-x[i+K-1]))
ans = min(ans, abs(x[i+K-1]) + abs(x[i]-x[i+K-1]))
print(ans) | p03274 |
R=[]
N,K=[int(i) for i in input().split()]
x=[int(i) for i in input().split()]
for i in range(N-K+1):
a=abs(x[i])+abs(x[i+K-1]-x[i])
b=abs(x[i+K-1])+abs(x[i+K-1]-x[i])
c=min(a,b)
R.append(c)
print((min(R))) | ANS=[]
N,K=[int(i) for i in input().split()]
x=[int(i) for i in input().split()]
for i in range(N-K+1):
a=x[i]
b=x[i+K-1]
A=abs(a)+abs(a-b)
B=abs(b)+abs(b-a)
c=min(A,B)
ANS.append(c)
print((min(ANS))) | p03274 |
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 100000000000000000000
for i in range(n-k+1):
a = x[i:i+k]
b = 0
if a[-1] <= 0:
b = -a[0]
elif a[0] >= 0:
b = a[-1]
else:
b = min(abs(a[0])*2+a[-1],a[-1]*2-a[0])
ans = min(ans,b)
print(ans) | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 100000000000000
a = 0
while a != n:
if x[a] >= 0:
break
a += 1
for i in range(max(0,a-k),n-k+1):
if x[i+k-1] <= 0:
ans = min(ans,-x[i])
elif x[i] >= 0:
ans = min(x[i+k-1],ans)
else:
ans = min(x[i+k-1]-x[i]+min(-x[i],x[i+k-1]),ans)
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = []
for i in range(n - k + 1):
left = x[i]
right = x[i + k - 1]
ans.append(min(abs(left) + abs(right - left),
abs(right) + abs(left - right)))
print((min(ans))) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = []
for i in range(n - k + 1):
left = x[i]
right = x[i + k - 1]
if abs(left) > abs(right):
ans.append(abs(right) + abs(left - right))
else:
ans.append(abs(left) + abs(right - left))
print((min(ans))) | p03274 |
N,K = list(map(int,input().split()))
X = list(map(int,input().split()))
ANS = []
for i in range(N-K+1) :
L = X[i:K+i]
l1 = abs(min(L))+abs(max(L)-min(L))
l2 = abs(max(L))+abs(max(L)-min(L))
ANS.append(min(l1,l2))
print((min(ANS)))
| N,K = list(map(int,input().split()))
L = list(map(int,input().split()))
ANS = []
for i in range(len(L)-K+1) :
p = L[i]
q = L[i+K-1]
if p*q == 0 :
r = abs(p-q)
elif p*q < 0 :
r = 2*min(abs(p),q) + max(abs(p),q)
else :
if p > 0 :
r = q
else :
r = abs(p)
ANS.append(r)
ans = min(ANS)
print(ans)
| p03274 |
N, K = list(map(int,input().split()))
X = list(map(int,input().split()))
result = []
for l, r in zip(X,X[K-1:]):
result.append((r - l + min(abs(l), abs(r))))
print((min(result))) | N, K = list(map(int,input().split()))
X = list(map(int,input().split()))
result = []
for l, r in zip(X,X[K-1:]):
result.append(r - l + min(abs(l), abs(r)))
print((min(result))) | p03274 |
N, K = list(map(int,input().split()))
X = list(map(int,input().split()))
result = []
for l, r in zip(X,X[K-1:]):
result.append(r - l + min(abs(l), abs(r)))
print((min(result))) | N, K = list(map(int,input().split()))
X = list(map(int,input().split()))
tmp = []
for l, r in zip(X,X[K-1:]):
tmp.append(r - l + min(abs(l), abs(r)))
print((min(tmp))) | p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float("inf")
for i in range(N - K + 1):
left, right = X[i], X[i + K - 1]
if left * right <= 0:
ans = min(ans, abs(left) + right + min(abs(left), right))
elif left > 0:
ans = min(ans, right)
else:
ans = min(ans, abs(left))
print(ans)
| N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float("inf")
for i in range(N - K + 1):
left, right = X[i], X[i + K - 1]
dist = right - left
ans = min(ans, abs(left) + dist, abs(right) + dist)
print(ans)
| p03274 |
n, k = list(map(int, input().split()))
ns = list(map(int, input().split()))
min_num = float('inf')
for i in range(n - k+1):
l = ns[i:i + k]
if l[-1] < 0:
min_num = min(min_num, abs(l[0]))
elif l[0] < 0 and l[-1] >= 0:
min_num = min(min_num, abs(l[0]) * 2 + l[-1])
min_num = min(min_num, abs(l[0]) + l[-1] * 2)
else:
min_num = min(min_num, l[-1])
print(min_num) | n, k = list(map(int, input().split()))
ns = list(map(int, input().split()))
min_num = float('inf')
for i in range(n - k+1):
l = ns[i]
r = ns[i+k-1]
min_num = min(min_num, abs(l) + abs(r-l), abs(r) + abs(l-r))
print(min_num) | p03274 |
# https://atcoder.jp/contests/abc107/tasks/arc101_a
# C - Candles
n, k = list(map(int, input().split()))
x_list = list(map(int, input().split()))
x_list = sorted(x_list)
min_l = float('inf')
minus_list = [x for x in x_list if x < 0]
plus_index = len(minus_list)
# print('plus_index: {}'.format(plus_index))
# plus_list = [x for x in work_list if x >= 0]
for i, x in enumerate(x_list):
l = 0
minus_list = []
plus_list = []
if i + k < plus_index:
# 全部負の数
minus_list = x_list[i:i+k]
plus_list = []
elif i > plus_index:
# 全部正の数
plus_list = x_list[i:i+k]
minus_list = []
else:
minus_list = x_list[i:plus_index]
diff = k - len(minus_list)
plus_list = x_list[plus_index: plus_index + (k - len(minus_list))]
# print(minus_list)
# print(plus_list)
minus_l = -minus_list[0] if minus_list else 0
plus_l = plus_list[-1] if plus_list else 0
# print('{}, {}'.format(minus_l, plus_l))
if plus_l > minus_l:
l = minus_l * 2 + plus_l
else:
l = plus_l * 2 + minus_l
if l < min_l:
min_l = l
if i + k > n - 1:
break
print(min_l) | # https://atcoder.jp/contests/abc107/tasks/arc101_a
# C - Candles
n, k = list(map(int, input().split()))
x_list = list(map(int, input().split()))
x_list = sorted(x_list)
min_l = float('inf')
minus_list = [x for x in x_list if x < 0]
plus_index = len(minus_list)
for i, x in enumerate(x_list):
left, right = x_list[i], x_list[i+k-1]
# 最左端に行ってから、最右端に行く
a = abs(left) + abs(left-right)
# 最右端に行ってから、最左端に行く
b = abs(right) + abs(right - left)
l = min(a, b)
if l < min_l:
min_l = l
if i + k > n - 1:
break
print(min_l)
| p03274 |
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
if (0 in x):
k-=1
else:
x.append(0)
x.sort()
time=[]
def measureTime(i,regX,nowTime,nowPlace,direct,turnFlg):
if i<k:
if len(regX)>1:
newRegX=regX[:]
newRegX.pop(nowPlace)
if (nowPlace>0) & ((direct==0)|(turnFlg!=1)):
newTimeM=nowTime+abs(regX[nowPlace]-regX[nowPlace-1])
# print('{},place={},time={}'.format(newRegX,nowPlace-1,newTimeM))
if direct==1:
turnFlg=1
measureTime(i+1, newRegX, newTimeM, nowPlace-1, 0, turnFlg)
if (nowPlace<len(regX)-1) & ((direct==1)|(turnFlg!=1)):
newTimeP=nowTime+abs(regX[nowPlace]-regX[nowPlace+1])
# print('{},place={},time={}'.format(newRegX,nowPlace,newTimeP))
if direct==0:
turnFlg=1
measureTime(i+1, newRegX, newTimeP, nowPlace, 1, turnFlg)
else:
if i==k:
time.append(nowTime)
else:
time.append(nowTime)
measureTime(0,x,0,x.index(0),-1,0)
time.sort()
print((time[0]))
| n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
if (0 in x):
k-=1
else:
x.append(0)
x.sort()
zeroPos=x.index(0)
leftLen=zeroPos
rightLen=len(x)-zeroPos-1
# print(leftLen,zeroPos,rightLen)
# print(x)
left=[]
right=[]
for turn in range(leftLen+1):
if(turn>k):
break
if(k-turn<=rightLen):
left.append(x[zeroPos-turn]*-2 + x[zeroPos+k-turn])
for turn in range(rightLen+1):
if(turn>k):
break
if(k-turn<=leftLen):
right.append(2*x[zeroPos+turn] + -1*x[zeroPos-k+turn])
minL=min(left)
minR=min(right)
# print(left,right)
print((minL if minL<minR else minR)) | p03274 |
n,k=list(map(int,input().split()))
add=list(map(int,input().split()))
ans=float("inf")
for l in range(n-k+1):
r=l+k-1
ans=min(ans,
abs(add[l])+abs(add[r]-add[l]),
abs(add[r])+abs(add[r]-add[l])
)
print(ans) | n,k=list(map(int,input().split()))
add=list(map(int,input().split()))
ans=float("inf")
for l in range(n-k+1):
r=l+k-1
ans=min(ans,
abs(add[l])+abs(add[l]-add[r]),
abs(add[r])+abs(add[r]-add[l])
)
#探索する量が少ないので全探索により答えを求めることができる
print(ans) | p03274 |
n,k=list(map(int,input().split()))
line=list(map(int,input().split()))
ans=float("inf")
for i in range(n-k+1):
left,right=i,i+k-1
ans=min(ans,
abs(line[left])+abs(line[left]-line[right]),
abs(line[right])+abs(line[right]-line[left])
)
print(ans) | n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
ans=float("inf")
for i in range(n-k+1):
l,r=i,i+k-1
ans=min(ans,abs(A[r]-A[l])+abs(A[r]),abs(A[l])+abs(A[l]-A[r]))
print(ans) | p03274 |
n,k=list(map(int,input().split()))
xs=list(map(int,input().split()))
a=float('inf')
for i in range(n-k+1):
x=xs[i:i+k]
l=abs(x[0])+abs(x[0]-x[-1])
r=abs(x[-1])+abs(x[0]-x[-1])
m=min(l,r)
a=min(a,m)
print(a) | n,k=list(map(int,input().split()))
xs=list(map(int,input().split()))
m=float('inf')
for l,r in zip(xs,xs[k-1:]):
d=min(abs(l),abs(r))+abs(r-l)
m=min(m,d)
print(m)
| p03274 |
n,k=list(map(int,input().split()))
lst=list(map(int,input().split()))
ans=float("inf")
for i in range(n-k+1):
tmp=lst[i:i+k]
left=tmp[0]
right=tmp[-1]
if left==0 and right==0:
print((0))
exit()
if left<0 and right<=0:
ans=min(ans,abs(left))
elif left<0 and right>0:
if abs(left)>abs(right):
ans=min(ans,abs(left)+right*2)
else:
ans=min(ans,abs(left)*2+right)
else:
ans=min(ans,right)
print(ans) | n,k=list(map(int,input().split()))
lst=list(map(int,input().split()))
ans=float("inf")
for i in range(n-k+1):
left=lst[i]
right=lst[i+k-1]
if left==0 and right==0:
print((0))
exit()
if left<0 and right<=0:
ans=min(ans,abs(left))
elif left<0 and right>0:
if abs(left)>abs(right):
ans=min(ans,abs(left)+right*2)
else:
ans=min(ans,abs(left)*2+right)
else:
ans=min(ans,right)
print(ans) | p03274 |
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
def culclen(l,r):
if X[l]*X[r]>=0:
return max(abs(X[l]),abs(X[r]))
else:
ldis=abs(X[l])
rdis=abs(X[r])
return min(ldis,rdis)*2+max(ldis,rdis)
ans=10**9
for x in range(len(X)-K+1):
ans=min(ans,culclen(x,x+K-1))
print(ans)
| N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
def culclen(l,r):
return abs(X[r]-X[l])+min(abs(X[l]),abs(X[r]))
ans=10**9
for x in range(len(X)-K+1):
ans=min(ans,culclen(x,x+K-1))
print(ans)
| p03274 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def II(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n,k=LI()
l=LI()
if l.count(0)>0:
k-=1
l.remove(0)
if k==0:
print((0))
exit()
if len(l)==0:
print((0))
exit()
idx=len(l)-1
for i in range(len(l)):
if l[i]>0:
idx=i
break
if max(l)<0:
idx=len(l)
l1=[abs(x) for x in l[idx:]]
l2=[abs(x) for x in l[:idx]]
l2.reverse()
# print(l1)
# print(l2)
mn=inf
for i in range(len(l1)):
if i+1>=k:
mn=min(mn,l1[i])
else:
if len(l2)>=k-(i+1):
# print(l1[i],l2[k-(i+1)-1])
mn=min(mn,l1[i]+2*l2[k-(i+1)-1])
for i in range(len(l2)):
if i+1>=k:
mn=min(mn,l2[i])
else:
if len(l1)>=k-(i+1):
# print(l2[i],l1[k-(i+1)-1])
mn=min(mn,l2[i]+2*l1[k-(i+1)-1])
print(mn)
main()
# print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n,k=LI()
l=LI()
mn=inf
for i in range(n-k+1):
a=l[i]
b=l[i+k-1]
if a<0 and b>0:
mn=min([mn,abs(a)+abs(b)*2,abs(a)*2+abs(b)])
else:
mn=min(mn,max(abs(a),abs(b)))
return mn
print((main()))
| p03274 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n,k=LI()
l=LI()
mn=inf
for i in range(n-k+1):
a=l[i]
b=l[i+k-1]
if a<0 and b>0:
mn=min([mn,abs(a)+abs(b)*2,abs(a)*2+abs(b)])
else:
mn=min(mn,max(abs(a),abs(b)))
return mn
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n,k=LI()
l=LI()
mn=inf
for i in range(n-k+1):
a=l[i]
b=l[i+k-1]
if a<0 and b>0:
mn=min(mn,abs(a)+abs(b)*2,abs(a)*2+abs(b))
else:
mn=min(mn,max(abs(a),abs(b)))
return mn
print((main()))
| p03274 |
def c_candles(N, K, X):
from bisect import bisect_left
negative_pos = X[:bisect_left(X, 0)][::-1]
positive_pos = X[bisect_left(X, 0):]
negative_pos_rel = negative_pos[:]
positive_pos_rel = positive_pos[:]
for k in range(1, len(negative_pos)):
negative_pos_rel[k] -= negative_pos[k - 1]
for k in range(1, len(positive_pos)):
positive_pos_rel[k] -= positive_pos[k - 1]
# print(X, negative_pos_rel, positive_pos_rel)
ans = float('inf')
for k in range(len(negative_pos) + 1):
length = 0
n = K - k
if n > len(positive_pos):
continue
length += abs(sum(negative_pos_rel[:k]))
length += length
length += sum(positive_pos_rel[:n])
ans = min(ans, length)
# print(n, k, length)
# print('-')
for n in range(len(positive_pos) + 1):
length = 0
k = K - n
if k > len(negative_pos):
continue
length += sum(positive_pos_rel[:n])
length += length
length += abs(sum(negative_pos_rel[:k]))
ans = min(ans, length)
# print(n, k, length)
return ans
N, K = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
print((c_candles(N, K, X))) | def c_candles(N, K, X):
ans = float('inf')
# [left, right] が指す連続したK本のろうそくに火をつけるといい
for left in range(N):
right = left + K - 1
if right >= N: # 右端がろうそくを指していない
break
# left→rightへ付けていく場合とright→leftへ付けていく場合
ans = min(ans, abs(X[left]) + abs(X[right] - X[left]))
ans = min(ans, abs(X[right]) + abs(X[right] - X[left]))
return ans
N, K = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
print((c_candles(N, K, X))) | p03274 |
import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
len_p = len([x for x in X if x > 0])
ans = 10**10
idx = max(0, len_m-K)
s = [0] + X[idx:idx+K-1]
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
s = s[1:] + [X[i+K-1]]
if len(s) != K:
continue
if s[0] < 0 and s[-1] > 0:
c = min(abs(s[0]) * 2 + s[-1], abs(s[0]) + s[-1] * 2)
else:
c = max(abs(s[0]), abs(s[-1]))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
len_p = len([x for x in X if x > 0])
ans = 10**10
idx = max(0, len_m-K)
s = [0] + X[idx:idx+K-1]
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
s.pop(0)
s.append(X[i+K-1])
if len(s) != K:
continue
if s[0] < 0 and s[-1] > 0:
c = min(abs(s[0]) * 2 + s[-1], abs(s[0]) + s[-1] * 2)
else:
c = max(abs(s[0]), abs(s[-1]))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | p03274 |
import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
len_p = len([x for x in X if x > 0])
ans = 10**10
idx = max(0, len_m-K)
s = [0] + X[idx:idx+K-1]
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
s = s[1:]
s.append(X[i+K-1])
if len(s) != K:
continue
if s[0] < 0 and s[-1] > 0:
c = min(abs(s[0]) * 2 + s[-1], abs(s[0]) + s[-1] * 2)
else:
c = max(abs(s[0]), abs(s[-1]))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
len_p = len([x for x in X if x > 0])
ans = 10**10
idx = max(0, len_m-K)
s = [0] + X[idx:idx+K-1]
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
s.pop(0)
s.append(X[i+K-1])
if s[0] < 0 and s[-1] > 0:
c = min(abs(s[0]) * 2 + s[-1], abs(s[0]) + s[-1] * 2)
else:
c = max(abs(s[0]), abs(s[-1]))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | p03274 |
import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
len_p = len([x for x in X if x > 0])
ans = 10**10
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
l = X[i]
r = X[i+K-1]
if l < 0 and r > 0:
c = min(abs(l) * 2 + r, abs(l) + r * 2)
else:
c = max(abs(l), abs(r))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
def main():
N, K = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
len_m = len([x for x in X if x < 0])
ans = 10**10
for i in range(max(0, len_m-K), min(len_m+K, N-K+1)):
l = X[i]
r = X[i+K-1]
if l < 0 and r > 0:
c = min(abs(l) * 2 + r, abs(l) + r * 2)
else:
c = max(abs(l), abs(r))
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() | p03274 |
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
T = []
for i in range(n - k + 1):
l = X[i]
r = X[i + k - 1]
route1 = abs(l) - l + r
route2 = abs(r) - l + r
temp = min(route1, route2)
T.append(temp)
print((min(T))) | n, k = list(map(int, input().split()))
C = list(map(int, input().split()))
D = []
for i in range(n - k + 1):
l = C[i]
r = C[i + k -1]
route1 = abs(l) - l + r
route2 = abs(r) - l + r
dist = min(route1, route2)
D.append(dist)
print((min(D))) | p03274 |
N , K = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float("inf")
for i in range(N - K + 1):
search_candles = x[i : i + K]
if search_candles[-1] <= 0:
tmp_min = abs(search_candles[0])
elif 0 <= search_candles[0]:
tmp_min = abs(search_candles[-1])
else:
PassTwice = min(abs(search_candles[-1]) ,abs(search_candles[0])) * 2
PassOnce = max(abs(search_candles[-1]) ,abs(search_candles[0]))
tmp_min = PassTwice + PassOnce
if tmp_min < ans:
ans = tmp_min
print(ans) | N , K = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float("inf")
for i in range(N - K + 1):
#x = x[i : i + K]
if x[i + K - 1] <= 0:
tmp_min = abs(x[i])
elif 0 <= x[i]:
tmp_min = abs(x[i + K - 1])
else:
PassTwice = min(abs(x[i + K - 1]) ,abs(x[i])) * 2
PassOnce = max(abs(x[i + K - 1]) ,abs(x[i]))
tmp_min = PassTwice + PassOnce
if tmp_min < ans:
ans = tmp_min
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9
for i in range(n - k + 1):
if x[i] < 0:
if x[i + k - 1] < 0:
ref = -x[i]
else:
ref = min(x[i]*-2 + x[i + k - 1], -x[i] + x[i + k - 1]*2)
else:
ref = x[i + k - 1]
ans = min(ans, ref)
print(ans) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
k -= 1
ans = 10**9
for i in range(n - k):
l = x[i]
r = x[i + k]
if l < 0:
if r < 0:
ref = -l
else:
ref = min(l*-2 + r, -l + r*2)
else:
ref = r
ans = min(ans, ref)
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = sorted(list(map(int, input().split())) + [0])
ans = 10**9 + 10
for i in range(n-k+1):
left = i
right = i+k
to_right = abs(x[left]) + abs(x[right]-x[left])
to_left = abs(x[right]) + abs(x[right]-x[left])
if min(to_right, to_left) < ans:
ans = min(to_right, to_left)
print(ans) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9 + 10
for i in range(n-k+1):
left = i
right = i+k-1
to_right = abs(x[left]) + abs(x[right]-x[left])
to_left = abs(x[right]) + abs(x[right]-x[left])
if min(to_right, to_left) < ans:
ans = min(to_right, to_left)
print(ans) | p03274 |
bitcount = [bin(i).count('1') for i in range(0x10000)]
def solve(a, b):
global bitcount
b = [65535 ^ bi for bi in b]
pdp = {a[0]:0}
ndp = {}
for ai in a[1:] + [0]:
for k, v in list(pdp.items()):
v += bitcount[k]
for bi in b:
bi &= k
vb = v - bitcount[bi]
bi |= ai
try:
ndp[bi] = max(ndp[bi], vb)
except KeyError:
ndp[bi] = vb
pdp, ndp = ndp, {}
return max(pdp.values())
import sys
f = sys.stdin
while True:
n, c = list(map(int, f.readline().split()))
if n == c == 0:
break
a = [int(''.join(f.readline().split()), 2) for i in range(n)]
b = [int(''.join(f.readline().split()), 2) for i in range(c)]
print((solve(a, b))) | bitcount = [bin(i).count('1') for i in range(0x10000)]
def solve(a, b):
global bitcount
b = [65535 ^ bi for bi in b]
pdp = {a[0]:0}
ndp = {}
for ai in a[1:] + [0]:
for k, v in list(pdp.items()):
v += bitcount[k]
for bi in b:
bi &= k
vb = v - bitcount[bi]
bi |= ai
try:
if ndp[bi] < vb:
ndp[bi] = vb
except KeyError:
ndp[bi] = vb
pdp, ndp = ndp, {}
return max(pdp.values())
import sys
f = sys.stdin
while True:
n, c = list(map(int, f.readline().split()))
if n == c == 0:
break
a = [int(''.join(f.readline().split()), 2) for i in range(n)]
b = [int(''.join(f.readline().split()), 2) for i in range(c)]
print((solve(a, b))) | p00258 |
a = int ( eval(input ( )) )
h = a // 3600
m = ( a // 60 ) % 60
d = a % 60
print(( "%s:%s:%s" % ( h, m, d ) )) | S = int(eval(input()))
h = S // 3600
m = (S // 60) % 60
s = S % 60
print(("%d:%d:%d" % (h, m, s)))
| p02390 |
S = int(eval(input()))
h = S // 3600
m = S // 60 % 60
s = S % 60
#print(str(h) + ':' + str(m) + ':' + str(s))
print(('{0}:{1}:{2}'.format(h,m,s))) | S = int(input())
h = S // 3600
m = S % 3600 // 60
s = S % 60
print(h,m,s, sep=':')
| p02390 |
S = int(input())
h = int(S / 3600)
m = int(S % 3600 / 60)
s = S % 60
print(h, m, s, sep=':')
| S = int(eval(input()))
s = S % 60
m = S // 60 % 60
h = S // 60 // 60
print(("{0}:{1}:{2}".format(h,m,s))) | p02390 |
s=int(eval(input()))
print(f'{s//3600}:{s//60%60}:{s%60}') | s=int(input())
print(s//3600,s//60%60,s%60,sep=':')
| p02390 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.