input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import bisect
import sys
import math
from collections import deque
from heapq import heappush, heappop
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
DIV = (10**9) + 7
#DIV = 998244353
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def CONV_TBL(max, mod=DIV):
fac, finv, inv = [0]*max, [0]*max, [0]*max
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, max):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod % i] * (mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
class CONV:
def __init__(self):
self.fac = fac
self.finv = finv
pass
def ncr(self, n, k):
if(n < k):
return 0
if(n < 0 or k < 0):
return 0
return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
return CONV()
def cumsum(As):
s = 0
for a in As:
s += a
yield s
sys.setrecursionlimit(200005)
def dijkstra(G,start=0):
heap = []
cost = [INF]*len(G)
heappush(heap,(0,start))
while len(heap)!=0:
c,n = heappop(heap)
if cost[n] !=INF:
continue
cost[n]=c
for e in G[n]:
ec,v = e
if cost[v]!=INF:
continue
heappush(heap,(ec+c,v))
return cost
def main():
cache={}
def f(s,cur=0):
if s in cache:
return cache[s]
ins = int(s,2)
if ins==0:
return cur
pc = sum([c=='1' for c in s])
next_s = bin(ins % pc)[2:]
ret = cur
if next_s in cache:
ret = cache[next_s]+cur
else:
ret = f(next_s,cur+1)
cache[s]=ret
return ret
N=iRaw()
Xs=sRaw()
for n in range(N):
xl = [x for x in Xs]
xl[n]="1" if xl[n]=="0" else "0"
print((f("".join(xl))))
main()
| import bisect
import sys
import math
from collections import deque
from heapq import heappush, heappop
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
DIV = (10**9) + 7
#DIV = 998244353
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def CONV_TBL(max, mod=DIV):
fac, finv, inv = [0]*max, [0]*max, [0]*max
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, max):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod % i] * (mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
class CONV:
def __init__(self):
self.fac = fac
self.finv = finv
pass
def ncr(self, n, k):
if(n < k):
return 0
if(n < 0 or k < 0):
return 0
return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
return CONV()
def cumsum(As):
s = 0
for a in As:
s += a
yield s
sys.setrecursionlimit(200005)
def dijkstra(G,start=0):
heap = []
cost = [INF]*len(G)
heappush(heap,(0,start))
while len(heap)!=0:
c,n = heappop(heap)
if cost[n] !=INF:
continue
cost[n]=c
for e in G[n]:
ec,v = e
if cost[v]!=INF:
continue
heappush(heap,(ec+c,v))
return cost
def main():
cache={"0":0}
def get_pc(s):
pc = sum([c == '1' for c in s])
return pc
def modPC(s,pc=None):
if pc==None:
pc =get_pc(s)
return int(s,2)%pc
def f(s,cur=0):
if s in cache:
return cache[s]
next_s = bin(modPC(s))[2:]
ret = f(next_s,cur+1)+1
cache[s]=ret
return ret
N=iRaw()
Xs=sRaw()
XPC = get_pc(Xs)
XmodPC=None
if XPC!=0:
XmodPC = modPC(Xs,XPC)
XmodPCP = modPC(Xs,XPC+1)
XmodPCN = None
if XPC>1:
XmodPCN= modPC(Xs,XPC-1)
for n in range(N):
if Xs[n]=='1':
if XPC==1:
print((0))
else:
nxt=(XmodPCN-pow(2,N-n-1,XPC-1))%(XPC-1)
nxt = bin(nxt)[2:]
print((f(nxt)+1))
else:
nxt = (XmodPCP+pow(2, N-n-1, XPC+1)) % (XPC+1)
nxt = bin(nxt)[2:]
print((f(nxt)+1))
main()
| p02609 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N = in_n()
X = in_s()
tx = int(X, 2)
ans = [0] * N
one_count = [X.count('1')] * N
for i in range(N):
if X[i] == '0':
one_count[i] += 1
else:
one_count[i] -= 1
t = 1 << N - 1
for i in range(N):
a = tx ^ t
count = 0
while a:
if count == 0:
a = a % one_count[i]
else:
a = a % bin(a).count('1')
count += 1
ans[i] = count
t = t >> 1
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = int(readline())
X = readline().rstrip().decode('utf-8')
nx = int(X, 2)
ans = [0] * N
oc = X.count('1')
if oc - 1 != 0:
mx = nx % (oc - 1)
f = True
else:
f = False
px = nx % (oc + 1)
for i in range(N):
if X[i] == '0':
a = (px + pow(2, N - i - 1, oc + 1)) % (oc + 1)
elif f:
a = (mx - pow(2, N - i - 1, oc - 1)) % (oc - 1)
else:
ans[i] = 0
continue
count = 1
while a:
a = a % bin(a).count('1')
count += 1
ans[i] = count
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main()
| p02609 |
# coding: utf-8
from collections import defaultdict, deque
def popcount(x):
assert x.bit_length() <= 32
x -= (x >> 1) & 0x55555555
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x += x >> 8
x += x >> 16
return x & 0x3f
def solve(*args: str) -> str:
n = int(args[0])
x = args[1]
ret = []
dp = defaultdict(int)
x_count = x.count('1')
x_dec = int(x, 2)
x_mod_set = x_dec % (x_count+1)
xor_set = 1 % (x_count+1)
if 1 < x_count:
x_mod_reset = x_dec % (x_count-1)
xor_reset = 1 % (x_count-1)
for i in range(n):
bitcount = x_count + (1 if x[-1-i] == '0' else -1)
if bitcount == 0:
ret.append(str(0))
continue
m = (x_mod_set + xor_set
if x[-1-i] == '0' else
x_mod_reset - xor_reset) % bitcount
deq = deque([m])
count = 1
while m:
deq.append(m)
if 0 < dp[m]:
count += dp[m]
break
m = m % popcount(m)
count += 1
ret.append(str(count))
while deq:
dp[deq.popleft()] = count
count -= 1
xor_set = (xor_set << 1) % (x_count+1)
if 1 < x_count:
xor_reset = (xor_reset << 1) % (x_count-1)
return '\n'.join(ret[::-1])
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| # coding: utf-8
def popcount(x):
assert x.bit_length() <= 32
x -= (x >> 1) & 0x55555555
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x += x >> 8
x += x >> 16
return x & 0x3f
def solve(*args: str) -> str:
n = int(args[0])
x = args[1]
ret = []
x_dec = int(x, 2)
x_count = x.count('1')
x_mod_set = x_dec % (x_count+1)
xor_set = 1 % (x_count+1)
if 1 < x_count:
x_mod_reset = x_dec % (x_count-1)
xor_reset = 1 % (x_count-1)
A = [0]
for i in range(1, x_count+2):
A.append(A[i % popcount(i)]+1)
for i in range(n):
bitcount = x_count + (1 if x[-1-i] == '0' else -1)
if bitcount == 0:
ret.append(str(0))
continue
m = x_mod_set + xor_set if x[-1-i] == '0' else x_mod_reset - xor_reset
m %= bitcount
ret.append(str(1+A[m]))
xor_set = (xor_set << 1) % (x_count+1)
if 1 < x_count:
xor_reset = (xor_reset << 1) % (x_count-1)
return '\n'.join(ret[::-1])
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| p02609 |
N = int(input())
S = str(input())
X = [];Bit = 0
for i in range(N):
if S[i] == "1":
Bit += 1
X.append(int(S[i]))
#print(X)
MAX = 2*pow(10,5)+10
small = [-1 for _ in range(MAX)]
small[0] = 0; small[1] = 1; small[2] = 1; small[3] = 2
for i in range(4,MAX):
ret = 0; target = i*1
while i > 0:
cnt = 0
for j in range(i.bit_length()):
if (i>>j)&1 == 1:
cnt += 1
i = i%cnt
#print(i,target,cnt)
ret += 1
if small[i] != -1:
ret += small[i]
break
small[target] = ret
#print(small)
Num = int(S, 2)
#print(Num)
ans = []
for i in range(N):
keta = N-1-i
if X[i] == 1:
temp = Num - pow(2,keta)
btemp = Bit -1
else:
temp = Num + pow(2,keta)
btemp = Bit + 1
if temp < MAX:
ret = small[temp]
else:
nokori = temp%btemp
ret = small[nokori] + 1 #最初の一回
ans.append(ret)
print(*ans,sep="\n")
| N = int(input())
S = str(input())
X = [];Bit = 0;Num = 0
for i in range(N):
if S[i] == "1":
Bit += 1
Num += pow(2,N-1-i)
X.append(int(S[i]))
#print(X)
#print(Num)
MAX = 2*pow(10,5)+10
small = [-1 for _ in range(MAX)]
small[0] = 0; small[1] = 1; small[2] = 1; small[3] = 2
for i in range(4,MAX):
ret = 0; target = i*1
while i > 0:
cnt = 0
for j in range(i.bit_length()):
if (i>>j)&1 == 1:
cnt += 1
i = i%cnt
#print(i,target,cnt)
ret += 1
if small[i] != -1:
ret += small[i]
break
small[target] = ret
#print(small)
if Bit -1 != 0:
Numm = Num%(Bit-1)
Nump = Num%(Bit+1)
#print(Num)
ans = []
for i in range(N):
keta = N-1-i
if X[i] == 1:
btemp = Bit -1
if btemp == 0:
ans.append(0)
continue
temp = (Numm - pow(2,keta,btemp))%btemp
else:
btemp = Bit +1
temp = (Nump + pow(2,keta,btemp))%btemp
ret = small[temp] + 1 #最初の一回
ans.append(ret)
print(*ans,sep="\n")
| p02609 |
def popcount(x):
return bin(x).count("1")
N, X = open(0).read().split()
N = int(N)
XS = list(X)
X = int(X, 2)
p = popcount(X)
if p == 0:
xi = xd = 0
elif p == 1:
xi = X % 2
xd = 0
else:
xi = X % (p + 1)
xd = X % (p - 1)
for i in range(0, N):
if XS[i] == "1":
if p == 1:
print((0))
continue
else:
k = 1 << (N - 1 - i)
x = (xd - k) % (p - 1)
else:
k = 1 << (N - 1 - i)
x = (xi + k) % (p + 1)
ans = 1
while x != 0:
x %= popcount(x)
ans += 1
print(ans) | def popcount(x):
return bin(x).count("1")
N, X = open(0).read().split()
N = int(N)
XS = list(X)
X = int(X, 2)
p = popcount(X)
xi = X % (p + 1)
if p == 1:
xd = 0
else:
xd = X % (p - 1)
for i in range(N):
if XS[i] == "1":
if p == 1:
print((0))
continue
else:
k = pow(2, N - 1 - i, p - 1)
x = (xd - k) % (p - 1)
else:
k = pow(2, N - 1 - i, p + 1)
x = (xi + k) % (p + 1)
ans = 1
while x != 0:
x %= popcount(x)
ans += 1
print(ans)
| p02609 |
import sys
input = sys.stdin.readline
import math
def read():
N = int(input().strip())
X = input().strip()
return N, X
def strdiv(X, k, d):
P = 0
q = 0
for i in range(len(X)):
q <<= 1
if i == k:
q |= 1-int(X[i])
else:
q |= int(X[i])
p, q = divmod(q, d)
# 商
P <<= 1
P |= p
return P, q
def solve(N, X):
P = [-1 for i in range(N+1)]
B = sum([1 for a in X if a == "1"])
for k in range(N):
if X[k] == "0":
b = (B + 1)
else:
b = (B - 1)
ans = 0
x = X
if b == 0:
print((0))
else:
# first step
p, q = strdiv(x, k, b)
ans += 1
x = bin(q)[2:]
b = sum([1 for a in x if a == "1"])
# second step (q < N)
if P[q] == -1:
r = q
while r > 0:
p, r = strdiv(x, k, b)
ans += 1
x = bin(r)[2:]
b = sum([1 for a in x if a == "1"])
P[q] = ans
print((P[q]))
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| import sys
input = sys.stdin.readline
import math
def read():
N = int(input().strip())
X = input().strip()
return N, X
def bitdiv(N:int, X:str, d:int):
q = 0
for i in range(N):
q <<= 1
q |= int(X[i])
p, q = divmod(q, d)
return q
def solve(N, X):
BP = [0 for i in range(N)]
BM = [0 for i in range(N)]
c = X.count("1")
# 2^k mod (c+1) を高速に求める
qp = bitdiv(N, X, c+1)
BP[N-1] = 1 % (c+1)
for i in range(N-2, -1, -1):
BP[i] = (BP[i+1] * 2) % (c+1)
# 2^k mod (c-1) を高速に求める
if c > 1:
qm = bitdiv(N, X, c-1)
BM[N-1] = 1 % (c-1)
for i in range(N-2, -1, -1):
BM[i] = (BM[i+1] * 2) % (c-1)
for i in range(N):
q = 0
ans = 0
if X[i] == "0":
# X_i \equiv (X + 2^i)
q = (qp + BP[i]) % (c+1)
ans += 1
elif X[i] == "1" and c > 1:
# X_i \equiv (X - 2^i)
q = (qm - BM[i]) % (c-1)
ans += 1
else:
q = 0
ans = 0
while q > 0:
q %= (bin(q).count("1"))
ans += 1
print(ans)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| p02609 |
import sys
input = sys.stdin.readline
import math
def read():
N = int(input().strip())
X = input().strip()
return N, X
def bitdiv(N:int, X:str, d:int):
q = 0
for i in range(N):
q <<= 1
q |= int(X[i])
p, q = divmod(q, d)
return q
def solve(N, X):
BP = [0 for i in range(N)]
BM = [0 for i in range(N)]
c = X.count("1")
# 2^k mod (c+1) を高速に求める
qp = bitdiv(N, X, c+1)
BP[N-1] = 1 % (c+1)
for i in range(N-2, -1, -1):
BP[i] = (BP[i+1] * 2) % (c+1)
# 2^k mod (c-1) を高速に求める
if c > 1:
qm = bitdiv(N, X, c-1)
BM[N-1] = 1 % (c-1)
for i in range(N-2, -1, -1):
BM[i] = (BM[i+1] * 2) % (c-1)
for i in range(N):
q = 0
ans = 0
if X[i] == "0":
# X_i \equiv (X + 2^i)
q = (qp + BP[i]) % (c+1)
ans += 1
elif X[i] == "1" and c > 1:
# X_i \equiv (X - 2^i)
q = (qm - BM[i]) % (c-1)
ans += 1
else:
q = 0
ans = 0
while q > 0:
q %= (bin(q).count("1"))
ans += 1
print(ans)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| import sys
input = sys.stdin.readline
import math
def read():
N = int(input().strip())
X = input().strip()
return N, X
def bitdiv(N:int, X:str, d:int):
q = 0
for i in range(N):
q <<= 1
q |= int(X[i])
p, q = divmod(q, d)
return q
def solve(N, X):
BP = [0 for i in range(N)]
BM = [0 for i in range(N)]
c = X.count("1")
# 2^k mod (c+1) を高速に求める
qp = int(X, base=2) % (c+1)
BP[N-1] = 1 % (c+1)
for i in range(N-2, -1, -1):
BP[i] = (BP[i+1] * 2) % (c+1)
# 2^k mod (c-1) を高速に求める
if c > 1:
qm = int(X, base=2) % (c-1)
BM[N-1] = 1 % (c-1)
for i in range(N-2, -1, -1):
BM[i] = (BM[i+1] * 2) % (c-1)
for i in range(N):
q = 0
ans = 0
if X[i] == "0":
# X_i \equiv (X + 2^i)
q = (qp + BP[i]) % (c+1)
ans += 1
elif X[i] == "1" and c > 1:
# X_i \equiv (X - 2^i)
q = (qm - BM[i]) % (c-1)
ans += 1
else:
q = 0
ans = 0
while q > 0:
q %= (bin(q).count("1"))
ans += 1
print(ans)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| p02609 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
X = input()
def popcount(n):
cnt = 0
while n:
n %= "{:b}".format(n).count("1")
cnt += 1
return cnt
pl = [0]*(N+1)
for i in range(N+1):
pl[i] = popcount(i)
bn = X.count("1")
modp = [0]*N
modm = [0]*N
for i in range(N):
if X[i] == "1":
modp[i] = pow(2, N-1-i, bn+1)
if not bn == 1:
modm[i] = pow(2, N-1-i, bn-1)
sp = sum(modp)
sm = sum(modm)
ans = [0]*N
for i in range(N):
if X[i] == "1":
if bn == 1:
ans[i] = 0
continue
s = sm
s -= modm[i]
s %= bn-1
ans[i] = pl[s]+1
else:
s = sp
s += pow(2, N-1-i, bn+1)
s %= bn+1
ans[i] = pl[s]+1
print(*ans, sep="\n")
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
X = input()
def bitcount(x):
'''xの立っているビット数をカウントする関数
(xは64bit整数)'''
# 2bitごとの組に分け、立っているビット数を2bitで表現する
x = x - ((x >> 1) & 0x5555555555555555)
# 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
x = x + (x >> 8) # 16bitごと
x = x + (x >> 16) # 32bitごと
x = x + (x >> 32) # 64bitごと = 全部の合計
return x & 0x0000007f
def popcount(n):
cnt = 0
while n:
n %= bitcount(n)
cnt += 1
return cnt
pl = [0]*(N+1)
for i in range(N+1):
pl[i] = popcount(i)
bn = X.count("1")
modp = [0]*N
modm = [0]*N
for i in range(N):
if X[i] == "1":
modp[i] = pow(2, N-1-i, bn+1)
if not bn == 1:
modm[i] = pow(2, N-1-i, bn-1)
sp = sum(modp)
sm = sum(modm)
ans = [0]*N
for i in range(N):
if X[i] == "1":
if bn == 1:
ans[i] = 0
continue
s = sm
s -= modm[i]
s %= bn-1
ans[i] = pl[s]+1
else:
s = sp
s += pow(2, N-1-i, bn+1)
s %= bn+1
ans[i] = pl[s]+1
print(*ans, sep="\n")
| p02609 |
import sys
def popcount(n):
return '{:b}'.format(n).count('1')
def f(n, firstpopcount):
if not n:
return 0
i = 1
n %= firstpopcount
# print(f'{n=}')
while n:
i += 1
n %= popcount(n)
return i
def resolve(in_):
n = int(in_.readline())
x = int(in_.readline(), 2)
xpopcount = popcount(x)
for i in range(n - 1, -1, -1):
s = 2 ** i
v = x ^ s
if v & s:
firstpopcount = xpopcount + 1
else:
firstpopcount = xpopcount - 1
# print(f'{x=:b} {v=:b} {1<<i=:b}')
print((f(v, firstpopcount)))
def main():
resolve(sys.stdin.buffer)
if __name__ == '__main__':
main() | import sys
def popcount(n):
c = 0
while n:
if n & 1:
c += 1
n >>= 1
return c
def f(n, c=0):
while pc := popcount(n):
n %= pc
c += 1
return c
def _resolve(n, x_bytes):
one_i = b'1'[0]
pc_x = x_bytes.count(b'1')
i2_mod_pc_x_p1 = [0] * n
i2_mod_pc_x_m1 = [0] * n
x_mod_pc_x_p1 = 0
x_mod_pc_x_m1 = 0
i2 = 1
x = 0
mod = pc_x + 1
for a in range(n):
i2_mod_pc_x_p1[- 1 - a] = i2
i2 *= 2
i2 %= mod
x *= 2
x %= mod
if (x_bytes[a] == one_i):
x += 1
x_mod_pc_x_p1 = x % mod
if pc_x > 1:
i2 = 1
x = 0
mod = pc_x - 1
for a in range(n):
i2_mod_pc_x_m1[- 1 - a] = i2
i2 *= 2
i2 %= mod
x *= 2
x %= mod
if (x_bytes[a] == one_i):
x += 1
x_mod_pc_x_m1 = x % mod
# print(pc_x)
# print(x_mod_pc_x_p1)
# print(x_mod_pc_x_m1)
# print(i2_mod_pc_x_p1)
# print(i2_mod_pc_x_m1)
for a in range(n):
if x_bytes[a] == one_i:
mod = pc_x - 1
if mod == 0:
yield 0
continue
b = x_mod_pc_x_m1 - i2_mod_pc_x_m1[a]
else:
mod = pc_x + 1
b = x_mod_pc_x_p1 + i2_mod_pc_x_p1[a]
b %= mod
yield f(b, 1)
def resolve(in_, out):
n = int(in_.readline())
x_bytes = in_.readline()
for ret in _resolve(n, x_bytes):
print(ret, file=out)
def main():
resolve(sys.stdin.buffer, sys.stdout)
if __name__ == '__main__':
main()
| p02609 |
# -*- coding: utf-8 -*-
from functools import lru_cache
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, X):
@lru_cache(maxsize=None)
def f(y):
c = bin(y).count('1')
if c == 0:
return 0
r = y % c
return 1 + f(r)
C = X.count('1')
cmr = 0
cpr = 0
for b in X:
cmr *= 2
cmr += int(b)
if C-1 == 0:
cmr = 0
else:
cmr %= C - 1
cpr *= 2
cpr += int(b)
cpr %= C + 1
bp = 1
bm = 1
ans = []
for i in range(N-1, -1, -1):
t = 1
if X[i] == '0':
x = (cpr + bp) % (C+1)
else:
if C-1 == 0:
x = 0
t = 0
else:
x = (cmr - bm) % (C-1)
while True:
c = bin(x).count('1')
# print(x, c)
if c == 0:
break
x = x % c
t += 1
ans.append(t)
bp *= 2
bp %= (C+1)
if C - 1 != 0:
bm *= 2
bm %= (C-1)
for a in reversed(ans):
print(a)
def main():
N = read_int()
X = read_str()
slv(N, X)
# import random
# N = 10**5
# N *= 2
# X = ''.join(random.choices('01', k=N))
# print(slv(N, X))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, X):
C = X.count('1')
cmr = 0
cpr = 0
for b in X:
if C-1 != 0:
cmr *= 2
cmr += int(b)
cmr %= C - 1
cpr *= 2
cpr += int(b)
cpr %= C + 1
for i in range(N):
t = 1
if X[i] == '0':
x = (cpr + pow(2, N-i-1, C+1)) % (C+1)
elif X[i] == '1' and C-1 != 0:
x = (cmr - pow(2, N-i-1, C-1)) % (C-1)
else:
x = 0
t = 0
while x != 0:
x = x % bin(x).count('1')
t += 1
print(t)
def main():
N = read_int()
X = read_str()
slv(N, X)
if __name__ == '__main__':
main()
| p02609 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_str():
return readline().strip()
def slv(N, X):
C = X.count('1')
cmr = 0
cpr = 0
for b in X:
cpr = ((cpr * 2) + int(b)) % (C+1)
for b in X:
if C-1 != 0:
cmr = ((cmr * 2) + int(b)) % (C-1)
ans = []
for i in range(N):
t = 1
if X[i] == '0':
x = (cpr + pow(2, N-i-1, C+1)) % (C+1)
elif X[i] == '1' and C-1 != 0:
x = (cmr - pow(2, N-i-1, C-1)) % (C-1)
else:
x = 0
t = 0
while x != 0:
x = x % bin(x).count('1')
t += 1
ans.append(t)
return ans
def main():
N = read_int()
X = read_str()
print(*slv(N, X), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_str():
return readline().strip()
def slv(N, X):
C = X.count('1')
cmr = 0
cpr = 0
for b in X:
b = int(b)
cpr = ((cpr * 2) + b) % (C+1)
if C-1 != 0:
cmr = ((cmr * 2) + b) % (C-1)
ans = []
for i in range(N):
t = 1
if X[i] == '0':
x = (cpr + pow(2, N-i-1, C+1)) % (C+1)
elif X[i] == '1' and C-1 != 0:
x = (cmr - pow(2, N-i-1, C-1)) % (C-1)
else:
x = 0
t = 0
while x != 0:
x = x % bin(x).count('1')
t += 1
ans.append(t)
return ans
def main():
N = read_int()
X = read_str()
print(*slv(N, X), sep='\n')
if __name__ == '__main__':
main()
| p02609 |
def popcount(n):
return bin(n).count("1")
cache = [-1] * (2 * 10 ** 5 + 1)
def f(n):
if cache[X] != -1:
return cache[X]
return f(n % popcount(n)) + 1
N = int(input())
X = int(input(), 2)
result = []
for i in range(N):
n = X ^ (1 << (N - 1 - i))
t = 0
while n != 0:
n %= popcount(n)
t += 1
result.append(t)
print(*result, sep='\n')
| def popcount(n):
return bin(n).count("1")
def f(n):
if n == 0:
return 0
return 1 + f(n % popcount(n))
N = int(input())
X = input()
c = X.count('1')
t1 = [0] * N
t1[0] = 1 % (c + 1)
for i in range(1, N):
t1[i] = (t1[i - 1] << 1) % (c + 1)
x1 = 0
for i in range(N):
if X[i] == '0':
continue
x1 += t1[N - 1 - i]
if c - 1 != 0:
t2 = [0] * N
t2[0] = 1 % (c - 1)
for i in range(1, N):
t2[i] = (t2[i - 1] << 1) % (c - 1)
x2 = 0
for i in range(N):
if X[i] == '0':
continue
x2 += t2[N - 1 - i]
result = []
for i in range(N):
if X[i] == '0':
n = (x1 + t1[N - 1 - i]) % (c + 1)
elif X[i] == '1':
if c - 1 == 0:
result.append(0)
continue
n = (x2 - t2[N - 1 - i]) % (c - 1)
result.append(1 + f(n))
print(*result, sep='\n')
| p02609 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from functools import lru_cache
@lru_cache(maxsize=2*10**5)
def f2(x):
if x == 0: return 0
y = bin(x).count("1")
return 1 + f2(x % y)
def resolve():
N = int(input())
W = 16
S = input()
cnt0 = S.count("1")
if cnt0 == 0:
print(*[1]*N, sep="\n")
return
X = int(S, 2)
dc = {}
for k, v in (("0", 1), ("1", -1)):
x = cnt0 + v
y = X % x if x else 0
dc[k] = (x, v, y)
ans = []
for i, si in enumerate(S):
cnt, v, n = dc[si]
if cnt == 0:
ans.append(0)
continue
ni = N - i - 1
n = (n + v * pow(2, ni, cnt)) % cnt
ans.append(1+f2(n))
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from functools import lru_cache
@lru_cache(maxsize=2*10**5)
def f2(x):
if x == 0: return 0
y = bin(x).count("1")
return 1 + f2(x % y)
def resolve():
N = int(input())
S = input()
cnt0 = S.count("1")
if cnt0 == 0:
print(*[1]*N, sep="\n")
return
X = int(S, 2)
dc = {}
for k, v in (("0", 1), ("1", -1)):
x = cnt0 + v
y = X % x if x else 0
dc[k] = (x, v, y, [1, N-1])
ans = [0] * N
for i in reversed(range(N)):
si = S[i]
cnt, v, n, m1 = dc[si]
if cnt == 0:
ans[i] = 0
continue
ni = N - i - 1
m2 = (m1[0]<<(m1[1]-i)) % cnt
n = (n + v*m2) % cnt
m1[0] = m2; m1[1] = i
ans[i] = 1 + f2(n)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| p02609 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from functools import lru_cache
@lru_cache(maxsize=2*10**5)
def f2(x):
if x == 0: return 0
y = bin(x).count("1")
return 1 + f2(x % y)
def resolve():
N = int(input())
S = input()
cnt0 = S.count("1")
if cnt0 == 0:
print(*[1]*N, sep="\n")
return
X = int(S, 2)
dc = {}
for k, v in (("0", 1), ("1", -1)):
x = cnt0 + v
y = X % x if x else 0
dc[k] = (x, v, y, [1, N-1])
ans = [0] * N
for i in reversed(range(N)):
si = S[i]
cnt, v, n, m1 = dc[si]
if cnt == 0:
ans[i] = 0
continue
ni = N - i - 1
m2 = (m1[0]<<(m1[1]-i)) % cnt
n = (n + v*m2) % cnt
m1[0] = m2; m1[1] = i
ans[i] = 1 + f2(n)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def resolve():
N = int(input())
S = input()
cnt0 = S.count("1")
if cnt0 == 0:
print(*[1]*N, sep="\n")
return
X = int(S, 2)
def f2():
cache = [-1] * max(9, cnt0+1)
cache[0] = 0
for i in range(3): cache[1<<i] = 1
def f2(x):
if cache[x] != -1:
#hit[x] += 1
return cache[x]
y = bin(x).count("1")
z = 1 + f2(x % y)
cache[x] = z
return z
f2.cache = cache
return f2
f2 = f2()
dc = {}
for k, v in (("0", 1), ("1", -1)):
x = cnt0 + v
y = X % x if x else 0
dc[k] = (x, v, y, [1, N-1])
ans = [0] * N
for i in reversed(range(N)):
si = S[i]
cnt, v, n, m1 = dc[si]
if cnt == 0:
ans[i] = 0
continue
ni = N - i - 1
m2 = (m1[0]<<(m1[1]-i)) % cnt
n = (n + v*m2) % cnt
m1[0] = m2; m1[1] = i
ans[i] = 1 + f2(n)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| p02609 |
n, X = open(0).read().split()
n = int(n)
x = int(X, 2)
X = list(map(int, X))
def popcount(q):
c = 0
while q:
q, r = divmod(q, 2)
c += r
return c
ma = 2 * 10**5 + 1
dp = [0] * ma
for i in range(1, ma):
dp[i] = dp[i % popcount(i)] + 1
c = popcount(x)
a = x % (c+1)
if c == 1:
for i in range(n):
if X[i]:
print((0))
else:
print((dp[(a + pow(2, n-i-1, c+1)) % (c+1)] + 1))
else:
b = x % (c-1)
for i in range(n):
if X[i]:
print((dp[(b - pow(2, n-i-1, c-1)) % (c-1)] + 1))
else:
print((dp[(a + pow(2, n-i-1, c+1)) % (c+1)] + 1)) | n, X = open(0).read().split()
n = int(n)
x = int(X, 2)
X = list(map(int, X))
def popcount(n):
return bin(n).count('1')
ma = 2 * 10**5 + 1
dp = [0] * ma
for i in range(1, ma):
dp[i] = dp[i % popcount(i)] + 1
c = popcount(x)
a = x % (c+1)
if c == 1:
for i in range(n):
if X[i]:
print((0))
else:
print((dp[(a + pow(2, n-i-1, c+1)) % (c+1)] + 1))
else:
b = x % (c-1)
for i in range(n):
if X[i]:
print((dp[(b - pow(2, n-i-1, c-1)) % (c-1)] + 1))
else:
print((dp[(a + pow(2, n-i-1, c+1)) % (c+1)] + 1)) | p02609 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
N = int(input())
s = input()
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
@lru_cache(None)
def r(n):
if n==0:
return 0
bc=0
for i in range(N):
if n>>i&1:
bc+=1
return r(n%bc)+1
mod=s.count("1")
c1=0
c2=0
cur1=1%(mod+1)
if mod>1:
cur2=1%(mod-1)
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
c2+=cur2
c2%=(mod-1)
cur1=cur1*2%(mod+1)
cur2=cur2*2%(mod-1)
else:
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
cur1=cur1*2%(mod+1)
for i in range(N):
if s[i]=="1":
f=-1
cmod=mod-1
else:
f=1
cmod=mod+1
if cmod==0:
print(0)
continue
if f==1:
n=c1+pow(2,N-1-i,cmod)
n%=cmod
else:
n=c2-pow(2,N-1-i,cmod)
n%=cmod
print(1+r(n))
#printe(c1,c2)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
N = int(input())
s = input()
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
@lru_cache(None)
def r(n):
if n==0:
return 0
bc=0
for i in range(n.bit_length()):
if n>>i&1:
bc+=1
return r(n%bc)+1
mod=s.count("1")
c1=0
c2=0
cur1=1%(mod+1)
if mod>1:
cur2=1%(mod-1)
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
c2+=cur2
c2%=(mod-1)
cur1=cur1*2%(mod+1)
cur2=cur2*2%(mod-1)
else:
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
cur1=cur1*2%(mod+1)
for i in range(N):
if s[i]=="1":
f=-1
cmod=mod-1
else:
f=1
cmod=mod+1
if cmod==0:
print(0)
continue
if f==1:
n=c1+pow(2,N-1-i,cmod)
n%=cmod
else:
n=c2-pow(2,N-1-i,cmod)
n%=cmod
print(1+r(n))
#printe(c1,c2)
if __name__ == "__main__":
main()
| p02609 |
"""
NTC here
"""
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
profile = 0
pypy = 1
def iin(): return int(input())
def lin(): return list(map(int, input().split()))
def main():
T = 1
while T:
T -= 1
dp = {}
n = iin()
a = list(map(int, list(input())))
ans = []
def calc(a, md):
ch = len(a)-1
rm = 0
for i in a:
if i:
rm = (rm+ pow(2, ch, md))%md
ch -= 1
return rm%md
def bin_calc(a):
ans = []
while a:
ans.append(a&1)
a >>= 1
return ans[::-1]
sm = sum(a)
# count = 0
for i in range(n):
sol = 0
s1 = sm - a[i]
a[i] = + (not a[i])
s1 += a[i]
a1 = a
dp1 = []
while s1:
# count += 1
# print(a1, s1)
sol += 1
rm = calc(a1, s1)
if rm:
if rm in dp:
sol += dp[rm]
break
dp1.append(rm)
a1 = bin_calc(rm)
s1 = sum(a1)
else:
break
a[i] = + (not a[i])
for i, j in enumerate(dp1):
dp[j] = sol-i-1
ans.append(sol)
print(*ans, sep='\n')
# print(count)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if pypy:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
if profile:
import cProfile
cProfile.run('main()')
else:
main()
| """
NTC here
"""
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
profile = 0
pypy = 1
def iin(): return int(input())
def lin(): return list(map(int, input().split()))
def main():
T = 1
while T:
T -= 1
n = iin()
a = list(map(int, list(input())))
ans = []
def calc(a, md):
ch = len(a)-1
rm = 0
for i in a:
if i:
rm = (rm+ pow(2, ch, md))%md
ch -= 1
return rm%md
def bin_calc(a):
ans = []
while a:
ans.append(a&1)
a >>= 1
return ans[::-1]
sm = sum(a)
dc = {}
if sm:
dc[sm] = calc(a, sm)
if sm-1>0:
dc[sm-1] = calc(a, sm-1)
dc[sm+1] = calc(a, sm+1)
# count = 0
for i in range(n):
sol = 0
s1 = sm - a[i]
a[i] = + (not a[i])
s1 += a[i]
if s1:
r1 = dc[s1]
if a[i]:
r1 = (r1 + pow(2, n-i-1, s1))%s1
else:
r1 = (r1 - pow(2, n-i-1, s1))%s1
sol += 1
a1 = bin_calc(r1)
s1 = sum(a1)
while s1:
# count += 1
# print(a1, s1)
sol += 1
rm = calc(a1, s1)
if rm:
a1 = bin_calc(rm)
s1 = sum(a1)
else:
break
a[i] = + (not a[i])
ans.append(sol)
print(*ans, sep='\n')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if pypy:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
if profile:
import cProfile
cProfile.run('main()')
else:
main()
| p02609 |
def popcount(n):
bit_count = bin(n).count('1')
n = n % bit_count
return n
if __name__ == "__main__":
import sys
readline = sys.stdin.readline
N = int(eval(input()))
X = readline()
bit_count = X.count('1')
X_int = int(X, 2)
for i in range(N):
# ビットの反転
bit_count_n = bit_count
X_rest = 0
if X[i] == '0':
bit_count_n += 1
X_rest = X_int + pow(2, N - 1 - i)
else:
bit_count_n -= 1
X_rest = X_int - pow(2, N - 1 - i)
if X_rest == 0:
print((0))
else:
popcount_X = X_rest % bit_count_n
counter = 1
while popcount_X != 0:
popcount_X %= bin(popcount_X).count('1')
counter += 1
print(counter)
| def popcount(n):
bit_count = bin(n).count('1')
n = n % bit_count
return n
if __name__ == "__main__":
import sys
readline = sys.stdin.readline
N = int(eval(input()))
X = readline()
bit_count = X.count('1')
mod1 = int(X, 2) % (bit_count + 1)
mod2 = int(X, 2) % (bit_count - 1) if (bit_count - 1) != 0 else 0
for i in range(N):
if X[i] == '0':
X_rest = (mod1 + pow(2, N - 1 - i, bit_count + 1)) % (bit_count + 1)
else:
if bit_count - 1 != 0:
X_rest = (mod2 - pow(2, N - 1 - i, bit_count - 1)) % (bit_count - 1)
else:
print((0))
continue
counter = 1
while X_rest != 0:
X_rest = popcount(X_rest)
counter += 1
print(counter)
| p02609 |
N = int(eval(input()))
X = input().strip()
def popcount(n):
cnt = 0
while n > 0:
cnt += n & 1
n //= 2
return cnt
def f(n):
cnt = 0
while n != 0:
n = n % popcount(n)
cnt += 1
return cnt
nX = int(X, 2)
pcnt = X.count('1')
MOD1 = pcnt + 1
MOD2 = pcnt - 1
nXp = nX % MOD1
if MOD2 != 0:
nXm = nX % MOD2
delta = 2**(N-1)
pow1 = [1] * N
pow2 = [0] * N
for i in range(1, N):
pow1[i] = (pow1[i-1] * 2) % MOD1
if MOD2 != 0:
pow2[0] = 1
for i in range(1, N):
pow2[i] = (pow2[i-1] * 2) % MOD2
for i in range(0, N):
if X[i] == '0':
k = (nXp + pow1[N-1-i]) % MOD1
print((f(k) + 1))
else:
if MOD2 == 0:
print((0))
else:
k = (nXm - pow2[N-1-i]) % MOD2
print((f(k) + 1))
delta //= 2 | import sys
N = int(sys.stdin.readline().strip())
X = sys.stdin.readline().strip()
def popcount(n):
cnt = 0
while n > 0:
cnt += n & 1
n //= 2
return cnt
def f(n):
cnt = 0
while n != 0:
n = n % popcount(n)
cnt += 1
return cnt
#nX = int(X, 2)
pcnt = X.count('1')
MOD1 = pcnt + 1
MOD2 = pcnt - 1
nXp = 0
nXm = 0
pow1 = [1] * N
pow2 = [0] * N
for i in range(1, N):
pow1[i] = (pow1[i-1] * 2) % MOD1
if MOD2 != 0:
pow2[0] = 1
for i in range(1, N):
pow2[i] = (pow2[i-1] * 2) % MOD2
for i in range(N):
if X[i] == '1':
nXp += pow1[N-1-i]
nXp %= MOD1
if MOD2 != 0:
for i in range(N):
if X[i] == '1':
nXm += pow2[N-1-i]
nXm %= MOD2
for i in range(0, N):
if X[i] == '0':
k = (nXp + pow1[N-1-i]) % MOD1
print((f(k) + 1))
else:
if MOD2 == 0:
print((0))
else:
k = (nXm - pow2[N-1-i]) % MOD2
print((f(k) + 1)) | p02609 |
import sys
from collections import defaultdict
sys.setrecursionlimit(300000)
memp = {}
def popcount(n):
if n == 0:
return 0
global memp
if n not in memp:
memp[n] = (n & 1) + popcount(n >> 1)
return memp[n]
memf = {}
def f(x):
if x == 0:
return 0
global memf
if x not in memf:
memf[x] = f(x % popcount(x)) + 1
return memf[x]
n = int(eval(input()))
x = input().rstrip()
ans = []
for j in range(n):
i = n - 1 - j
a = str(1 - int(x[i]))
b = x[:i] + a + x[i+1:]
ans.append(f(int(b, 2)))
for j in range(n):
i = n - 1 - j
print((ans[i])) | import sys
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(300000)
memp = {}
def popcount(n):
if n == 0:
return 0
global memp
if n not in memp:
memp[n] = (n & 1) + popcount(n >> 1)
return memp[n]
memf = {}
def f(x):
if x == 0:
return 0
global memf
if x not in memf:
memf[x] = f(x % popcount(x)) + 1
return memf[x]
n = int(eval(input()))
x = input().rstrip()
init = Counter(x)['1']
for i in range(n):
if x[i] == '1':
pc = init - 1
else:
pc = init + 1
nn = int(x[:i] + str(1 - int(x[i])) + x[i+1:], 2)
if nn == 0:
print((0))
continue
nn = nn % pc
ans = 1
while nn != 0:
nn = nn % popcount(nn)
ans += 1
print(ans)
| p02609 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
s = S()
t = int(s, 2)
m = {}
m[0] = 0
def f(i):
if i in m:
return m[i]
c = 0
ii = i
while ii > 0:
c += ii % 2
ii //= 2
t = i % c
m[i] = f(t) + 1
return m[i]
c = len([_ for _ in s if _ == '1'])
r = []
k = 2 ** (n-1)
for i in range(n):
if t == k:
r.append(0)
elif s[i] == '1':
r.append(f((t - k) % (c-1)) + 1)
else:
r.append(f((t + k) % (c+1)) + 1)
k //= 2
return JA(r, "\n")
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
s = S()
m = {}
m[0] = 0
def f(i):
if i in m:
return m[i]
c = 0
ii = i
while ii > 0:
c += ii % 2
ii //= 2
t = i % c
m[i] = f(t) + 1
return m[i]
c = len([_ for _ in s if _ == '1'])
t = int(s, 2)
cm = (c+1) * c * (c-1)
if c > 1:
t %= cm
r = []
k = 1
for i in range(n-1,-1,-1):
if t == k:
r.append(0)
elif s[i] == '1':
r.append(f((t - k) % (c-1)) + 1)
else:
r.append(f((t + k) % (c+1)) + 1)
k *= 2
if c > 1:
k %= cm
return JA(r[::-1], "\n")
print(main())
| p02609 |
def solve():
N = int(input())
X = input()
bl = X.count('1')
bitp = 0
for i in range(N):
bitp += int(X[i])*pow(2,N-1-i)
bitp %= bl+1
bitm = 0
if bl>1:
for i in range(N):
bitm += int(X[i])*pow(2,N-1-i)
bitm %= bl-1
ans = [0]*N
dp = [0]*(N+1)
for i in range(1,N+1):
dp[i] = dp[i%(bin(i).count('1'))]+1
for i in range(N):
if X[i]=='1':
bit1 = bitm - pow(2,N-1-i)
bl1 = bl-1
if bl1==0:
ans[i] = 0
continue
else:
bit1 = bitp + pow(2,N-1-i)
bl1 = bl+1
ans[i] = dp[bit1%bl1]+1
return ans
print(*solve(),sep='\n')
| def solve():
N = int(input())
X = input()
bl = X.count('1')
bitp = 0
for i in range(N):
bitp += int(X[i])*pow(2,N-1-i,bl+1)
bitp %= bl+1
bitm = 0
if bl>1:
for i in range(N):
bitm += int(X[i])*pow(2,N-1-i,bl-1)
bitm %= bl-1
ans = [0]*N
dp = [0]*(N+1)
for i in range(1,N+1):
dp[i] = dp[i%(bin(i).count('1'))]+1
for i in range(N):
if X[i]=='1':
bl1 = bl-1
if bl1==0:
ans[i] = 0
continue
bit1 = bitm - pow(2,N-1-i,bl1)
else:
bl1 = bl+1
bit1 = bitp + pow(2,N-1-i,bl1)
ans[i] = dp[bit1%bl1]+1
return ans
print(*solve(),sep='\n')
| p02609 |
### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(20000000)
def yn(b):
print(("Yes" if b==1 else "No"))
return
def count_ones_by_bin(num):
bin_num = bin(num)[2:]
count = 0
for i in bin_num:
count += int(i)
return count
def resolve():
readline=sys.stdin.readline
n=int(readline())
x=readline().rstrip()
#pc=[0]*(10**5+1)
#for i in range(1,10**5):
# pc[i]=count_ones_by_bin(i)
amr1=[0]*((10**5)*2 + 5)
amr2=[0]*((10**5)*2 + 5)
bits=[False]*((10**5)*2 + 5)
pc=[-1]*((10**5)*2 + 5)
bcnt=0
j=0
for i in x:
if int(i)==1:
bcnt += 1
bits[j]=True
j+=1
base1=0
base2=0
for i in range(n):
jo=n-i-1
amr1[i]=pow(2,jo,bcnt+1)
if (bcnt-1)==0:
amr2[i]=pow(2,jo)
else:
amr2[i]=pow(2,jo,bcnt-1)
if bits[i]==True:
base1+=amr1[i]
base2+=amr2[i]
for i in range(n):
ans=0
if bits[i]==True: #1->0
if (bcnt-1)==0:
base=0
else:
base=(base2-amr2[i])%(bcnt-1)
ans+=1
else:
base=(base1+amr1[i])%(bcnt+1)
ans+=1
while base > 0:
if pc[base]==-1:
pc[base]=count_ones_by_bin(base)
base=base%pc[base]
ans+=1
print(ans)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ---------------- | ### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(20000000)
def yn(b):
print(("Yes" if b==1 else "No"))
return
def count_ones_by_bin(num):
bin_num = bin(num)[2:]
count = 0
for i in bin_num:
count += int(i)
return count
def resolve():
readline=sys.stdin.readline
n=int(readline())
x=readline().rstrip()
#pc=[0]*(10**5+1)
#for i in range(1,10**5):
# pc[i]=count_ones_by_bin(i)
amr1=[0]*((10**5)*2 + 5)
amr2=[0]*((10**5)*2 + 5)
bits=[False]*((10**5)*2 + 5)
pc=[-1]*((10**5)*2 + 5)
bcnt=0
j=0
for i in x:
if int(i)==1:
bcnt += 1
bits[j]=True
j+=1
base1=0
base2=0
ni1=1
ni2=1
for j in range(n):
i=n-1-j
jo=n-i-1
if j > 0:
ni1*=2
ni2*=2
#amr1[i]=pow(2,jo,bcnt+1)
ni1=ni1%(bcnt+1)
amr1[i]=ni1
if (bcnt-1)==0:
amr2[i]=0 #pow(2,jo)
else:
#amr2[i]=pow(2,jo,bcnt-1)
ni2=ni2%(bcnt-1)
amr2[i]=ni2
if bits[i]==True:
base1+=amr1[i]
base2+=amr2[i]
for i in range(n):
ans=0
if bits[i]==True: #1->0
if (bcnt-1)==0:
base=0
else:
base=(base2-amr2[i])%(bcnt-1)
ans+=1
else:
base=(base1+amr1[i])%(bcnt+1)
ans+=1
while base > 0:
if pc[base]==-1:
pc[base]=count_ones_by_bin(base)
base=base%pc[base]
ans+=1
print(ans)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ---------------- | p02609 |
from functools import lru_cache
def popcnt(x):
return bin(x).count("1")
@lru_cache(maxsize=None)
def rec(n):
if n == 0:
return 0
else:
return rec(n % popcnt(n)) + 1
ret = [rec(x) for x in range(2 * 10**5 + 1)]
n = int(input())
arr = input()
ALL_ARR = int(arr, 2)
cnt = popcnt(int(arr, 2))
init_big = ALL_ARR % (cnt + 1)
if cnt == 1:
init_small = 0
else:
init_small = ALL_ARR % (cnt - 1)
li = [0] * n
for i in range(n):
if arr[i] == "0":
li[i] = (init_big + (1 << (n - i - 1))) % (cnt + 1)
elif ALL_ARR - (1 << (n - i - 1)) == 0 or cnt - 1 == 0:
li[i] = "flg"
else:
li[i] = (init_small - (1 << (n - i - 1))) % (cnt - 1)
ans = []
for x in li:
if x == "flg":
ans.append(0)
else:
ans.append(ret[x] + 1)
print(*ans, sep="\n")
| from functools import lru_cache
def popcnt(x):
return bin(x).count("1")
@lru_cache(maxsize=None)
def rec(n):
if n == 0:
return 0
else:
return rec(n % popcnt(n)) + 1
ret = [rec(x) for x in range(2 * 10**5 + 1)]
n = int(input())
arr = input()
ALL_ARR = int(arr, 2)
cnt = popcnt(int(arr, 2))
init_big = ALL_ARR % (cnt + 1)
if cnt == 1:
init_small = 0
else:
init_small = ALL_ARR % (cnt - 1)
li = [0] * n
for i in range(n):
if arr[i] == "0":
li[i] = (init_big + pow(2, n - i - 1, cnt + 1)) % (cnt + 1)
elif ALL_ARR - (1 << (n - i - 1)) == 0 or cnt - 1 == 0:
li[i] = "flg"
else:
li[i] = (init_small - pow(2, n - i - 1, cnt - 1)) % (cnt - 1)
ans = []
for x in li:
if x == "flg":
ans.append(0)
else:
ans.append(ret[x] + 1)
print(*ans, sep="\n")
| p02609 |
from functools import lru_cache
def popcnt(x):
return bin(x).count("1")
@lru_cache(maxsize=None)
def rec(n):
if n == 0:
return 0
else:
return rec(n % popcnt(n)) + 1
ret = [rec(x) for x in range(2 * 10**5 + 1)]
n = int(input())
arr = input()
ALL_ARR = int(arr, 2)
cnt = popcnt(int(arr, 2))
init_big = ALL_ARR % (cnt + 1)
if cnt == 1:
init_small = 0
else:
init_small = ALL_ARR % (cnt - 1)
li = [0] * n
for i in range(n):
if arr[i] == "0":
li[i] = (init_big + pow(2, n - i - 1, cnt + 1)) % (cnt + 1)
elif ALL_ARR - (1 << (n - i - 1)) == 0 or cnt - 1 == 0:
li[i] = "flg"
else:
li[i] = (init_small - pow(2, n - i - 1, cnt - 1)) % (cnt - 1)
ans = []
for x in li:
if x == "flg":
ans.append(0)
else:
ans.append(ret[x] + 1)
print(*ans, sep="\n")
| from functools import lru_cache
def popcnt(x):
return bin(x).count("1")
@lru_cache(maxsize=None)
def rec(n):
if n == 0:
return 0
else:
return rec(n % popcnt(n)) + 1
n = int(input())
arr = input()
ALL_ARR = int(arr, 2)
cnt = popcnt(int(arr, 2))
init_big = ALL_ARR % (cnt + 1)
if cnt == 1:
init_small = 0
else:
init_small = ALL_ARR % (cnt - 1)
li = [0] * n
for i in range(n):
if arr[i] == "0":
li[i] = (init_big + pow(2, n - i - 1, cnt + 1)) % (cnt + 1)
elif ALL_ARR - (1 << (n - i - 1)) == 0 or cnt - 1 == 0:
li[i] = "flg"
else:
li[i] = (init_small - pow(2, n - i - 1, cnt - 1)) % (cnt - 1)
ans = []
for x in li:
if x == "flg":
ans.append(0)
else:
ans.append(rec(x) + 1)
print(*ans, sep="\n")
| p02609 |
def main():
import sys
input=sys.stdin.readline
n=int(eval(input()))
x=input().rstrip()
p=x.count("1")
minus=0
plus=0
numlst=[0]*n
for i in range(n):
number=2**i
numlst[-i-1]=number
if x[-i-1]=="1":
plus+=number
plus%=(p+1)
if p!=1:
minus+=number
minus%=(p-1)
def popcnt(x):
cnt=str(bin(x)).count("1")
x%=cnt
return x
for i in range(n):
if x[i]=="0":
amari=(plus+numlst[i]%(p+1))%(p+1)
ans=1
while amari>=1:
amari=popcnt(amari)
ans+=1
print(ans)
else:
if p==1:
print((0))
continue
amari=(minus-numlst[i]%(p-1))%(p-1)
ans=1
while amari>=1:
amari=popcnt(amari)
ans+=1
print(ans)
if __name__ == "__main__":
main() | import sys
input=sys.stdin.readline
n=int(eval(input()))
x=input().rstrip()
x10=int(x,2)
pcx=x.count("1")
plus=x10%(pcx+1)
if pcx>=2:
minus=x10%(pcx-1)
def popcnt(x):
cnt=1
while x>=1:
x%=(bin(x).count("1"))
cnt+=1
return cnt
for i in range(n):
if x[i]=="0":
amari=(plus+pow(2,n-i-1,pcx+1))%(pcx+1)
print((popcnt(amari)))
else:
if pcx==1:
print((0))
else:
amari=(minus-pow(2,n-i-1,pcx-1))%(pcx-1)
print((popcnt(amari))) | p02609 |
import sys
readline = sys.stdin.readline
N = int(readline())
X = readline().rstrip()
X0 = int(X, 2)
count1 = X.count("1")
X0mod0to1 = X0 % (count1 + 1) # 0->1に変化した際の、X0を割った余り
if count1 > 1:
X0mod1to0 = X0 % (count1 - 1) # 1->0に変化した際の、X0を割った余り
else:
X0mod1to0 = 0
from collections import defaultdict
dp = defaultdict(int)
dp[0] = 0
def f(x): # 愚直にf(x)を求める式
if x in dp:
return dp[x]
pc = bin(x).count("1")
val = f(x % pc) + 1
dp[x] = val
return val
val = 1
ans = [-1] * N
for i in range(N - 1, -1, -1): # 下の桁から順に、f(Xi)の値を求める
if X[i] == "0": # 0を1に変える場合
pat = (X0mod0to1 + val % (count1 + 1)) % (count1 + 1)
ans[i] = f(pat) + 1
elif X[i] == "1": # 1を0に変える場合
if count1 > 1:
pat = (X0mod1to0 - val % (count1 - 1)) % (count1 - 1)
ans[i] = f(pat) + 1
else:
ans[i] = 0
val *= 2
print(*ans, sep = "\n")
| import sys
readline = sys.stdin.readline
N = int(readline())
X = readline().rstrip()
X0 = int(X, 2)
count1 = X.count("1")
X0mod0to1 = X0 % (count1 + 1) # 0->1に変化した際の、X0を割った余り
if count1 > 1:
X0mod1to0 = X0 % (count1 - 1) # 1->0に変化した際の、X0を割った余り
else:
X0mod1to0 = 0
from collections import defaultdict
dp = defaultdict(int)
dp[0] = 0
def f(x): # 愚直にf(x)を求める式
if x in dp:
return dp[x]
pc = bin(x).count("1")
val = f(x % pc) + 1
dp[x] = val
return val
val0to1 = 1
val1to0 = 1
ans = [-1] * N
for i in range(N - 1, -1, -1): # 下の桁から順に、f(Xi)の値を求める
if X[i] == "0": # 0を1に変える場合
pat = (X0mod0to1 + val0to1 % (count1 + 1)) % (count1 + 1)
ans[i] = f(pat) + 1
elif X[i] == "1": # 1を0に変える場合
if count1 > 1:
pat = (X0mod1to0 - val1to0 % (count1 - 1)) % (count1 - 1)
ans[i] = f(pat) + 1
else:
ans[i] = 0
val0to1 = val0to1 * 2 % (count1 + 1)
if count1 != 1:
val1to0 = val1to0 * 2 % (count1 - 1)
print(*ans, sep = "\n")
| p02609 |
def getStart(field):
search_field = field[1:]
for y in range(len(search_field)):
for x in range(len(search_field[0])):
if search_field[y][x] == "S":
return x,y+1
def bfs(field,start_x,start_y,goal_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
gotten_cheese = 1
distance = 0
que = []
que.append([start_x,start_y,gotten_cheese,distance])
INF = 1
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < field[0][1] and 1 <= ny < field[0][0]+1 and field[ny][nx] != "X" and min_path[ny-1][nx] == INF:
if field[ny][nx] == current[2]:
if field[ny][nx] == goal_N:
print((current[3]+1))
return
else: # not goal, but could eat cheese
que = []
que.append([nx,ny,current[2]+1,current[3]+1])
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
break
else:
que.append([nx,ny,current[2],current[3]+1])
min_path[ny-1][nx] = 0
def main(field):
sx,sy = getStart(field)
bfs(field,sx,sy,field[0][2])
matrix = []
while True:
row = input().rstrip().split()
if len(row) == 3:
re_row = []
for i in row:
re_row.append(int(i))
matrix.append(re_row)
else:
re_row = []
for char in row[0]:
if char.isdigit():
re_row.append(int(char))
else:
re_row.append(char)
matrix.append(re_row)
if len(matrix) == int(matrix[0][0]) + 1:
main(matrix)
break | import sys
sys.setrecursionlimit(100000000)
moves = [(0, -1), (0, 1), (-1, 0), (1, 0)]
def search(dataset):
min_time = 0
mouse = 1
gx, gy = get_start(dataset)
for i in range(N):
gx, gy, min_time_tmp = bfs(dataset, (gx, gy), mouse)
mouse += 1
min_time += min_time_tmp
print(min_time)
def bfs(dataset, start, mouse):
INF = 10000000
min_time = [[INF for j in range(W)] for i in range(H)]
min_time[start[0]][start[1]] = 0
queue = [start]
while len(queue) != 0:
dx, dy = queue.pop(0)
for i, j in moves:
nx = dx + i
ny = dy + j
if 0 <= nx < H and 0 <= ny < W and dataset[nx][ny] != 'X' and min_time[nx][ny] == INF:
cell = dataset[nx][ny]
else:
continue
if type(cell) is int:
if mouse == int(cell):
min_time[nx][ny] = min_time[dx][dy] + 1
return nx, ny, min_time[nx][ny]
min_time[nx][ny] = min_time[dx][dy] + 1
queue.append((nx, ny))
def get_start(dataset):
for i in range(H):
rows = dataset[i]
for j in range(W):
cell = rows[j]
if cell == 'S':
return i, j
dataset = []
while True:
line = input().rstrip().split()
if len(line) == 3:
H, W, N = list(map(int, line))
else:
row = []
for e in line[0]:
if e.isdigit():
row.append(int(e))
else:
row.append(e)
dataset.append(row)
if len(dataset) == H:
search(dataset)
break | p00481 |
def getStart(field):
search_field = field[1:]
for y in range(len(search_field)):
for x in range(len(search_field[0])):
if search_field[y][x] == "S":
return x,y+1
def bfs(field,start_x,start_y,goal_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
gotten_cheese = 1
distance = 0
que = []
que.append([start_x,start_y,gotten_cheese,distance])
INF = 1
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < field[0][1] and 1 <= ny < field[0][0]+1 and field[ny][nx] != "X" and min_path[ny-1][nx] == INF:
if field[ny][nx] == current[2]:
if field[ny][nx] == goal_N:
print((current[3]+1))
return
else:
que = []
que.append([nx,ny,current[2]+1,current[3]+1])
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
break
else:
que.append([nx,ny,current[2],current[3]+1])
min_path[ny-1][nx] = 0
def main(field):
sx,sy = getStart(field)
bfs(field,sx,sy,field[0][2])
matrix = []
while True:
row = input().rstrip().split()
if len(row) == 3:
re_row = []
for i in row:
re_row.append(int(i))
matrix.append(re_row)
else:
re_row = []
for char in row[0]:
if char.isdigit():
re_row.append(int(char))
else:
re_row.append(char)
matrix.append(re_row)
if len(matrix) == int(matrix[0][0]) + 1:
main(matrix)
break |
def getStart(field):
search_field = field[1:] # cut the first [H,W,N] for min_path matrix
for y in range(len(search_field)):
for x in range(len(search_field[0])):
if search_field[y][x] == "S":
return x,y+1
def bfs(field,start_x,start_y,goal_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
gotten_cheese = 1
distance = 0
que = []
que.append([start_x,start_y,gotten_cheese,distance])
INF = 1
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < field[0][1] and 1 <= ny < field[0][0]+1 and field[ny][nx] != "X" and min_path[ny-1][nx] == INF:
if field[ny][nx] == current[2]: # at the same cheese-power number
if field[ny][nx] == goal_N: # goal
print((current[3]+1))
return
else: # not goal, but could eat cheese
que = []
que.append([nx,ny,current[2]+1,current[3]+1])
min_path = [[INF for j in range(field[0][1])] for i in range(field[0][0])]
break
else:
que.append([nx,ny,current[2],current[3]+1])
min_path[ny-1][nx] = 0
def main(field):
# field = [[10,10,9],
# [".","X",".",".",".","X",".","S",".","X"],
# [6,".",".",5,"X",".",".","X",1,"X"],
# [".",".",".","X","X","X","X",".",".","X"],
# ["X",".",".",9,"X",".",".",".","X","."],
# [8,".","X",2,"X",".",".","X",3,"X"],
# [".",".",".","X","X",".","X",4,".","."],
# ["X","X",".",".",".",".",7,"X",".","."],
# ["X",".",".","X",".",".","X","X",".","."],
# ["X",".",".",".","X",".","X","X",".","."],
# [".",".","X",".",".",".",".",".",".","."]]
sx,sy = getStart(field)
bfs(field,sx,sy,field[0][2])
# field = []
# while True:
# row = input().split()
# for i in range(len(row)):
# try:
# row[i] = int(row[i])
# except:
# continue
# field.append(row)
# if len(field) == field[0][0] + 1:
# main(field)
# break
matrix = []
while True:
row = input().rstrip().split()
if len(row) == 3:
re_row = []
for i in row:
re_row.append(int(i))
matrix.append(re_row)
else:
re_row = []
for char in row[0]:
if char.isdigit():
re_row.append(int(char))
else:
re_row.append(char)
matrix.append(re_row)
if len(matrix) == int(matrix[0][0]) + 1:
main(matrix)
break | p00481 |
from collections import deque
def getStart(field):
search_field = field[1:] # cut the first [H,W,N] for min_path matrix
for y in range(len(search_field)):
for x in range(len(search_field[0])):
if search_field[y][x] == "S":
return x,y+1
def bfs(field,start_x,start_y,goal_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
gotten_cheese = 1
distance = 0
que = []
que.append([start_x,start_y])
INF = 1000000
min_path = [[INF] * field[0][1] for i in range(field[0][0])]
min_path[start_y-1][start_x] = 0
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < field[0][1] and 1 <= ny < field[0][0]+1 and field[ny][nx] != "X" and min_path[ny-1][nx] == INF:
min_path[ny-1][nx] = min_path[current[1]-1][current[0]] + 1
if field[ny][nx] == gotten_cheese:
distance += min_path[ny-1][nx]
if field[ny][nx] == goal_N: # goal
print(distance)
return
else: # not goal, but could eat cheese
que = []
que.append([nx,ny])
gotten_cheese += 1
min_path = [[INF] * field[0][1] for i in range(field[0][0])]
min_path[ny-1][nx] = 0
break
else:
que.append([nx,ny])
def main(field):
sx,sy = getStart(field)
bfs(field,sx,sy,field[0][2])
matrix = []
while True:
row = input().rstrip().split()
if len(row) == 3:
re_row = []
for i in row:
re_row.append(int(i))
matrix.append(re_row)
else:
re_row = []
for char in row[0]:
if char.isdigit():
re_row.append(int(char))
else:
re_row.append(char)
matrix.append(re_row)
if len(matrix) == int(matrix[0][0]) + 1:
main(matrix)
break |
def bfs(field,H,W,start_x,start_y,tmp_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
que = []
que.append([start_x,start_y])
INF = 1000000
min_path = [[INF] * W for i in range(H)]
min_path[start_y][start_x] = 0
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < W and 0 <= ny < H and field[ny][nx] != "X" and min_path[ny][nx] == INF:
min_path[ny][nx] = min_path[current[1]][current[0]] + 1
if field[ny][nx] == tmp_N: # at the same cheese-power number
return nx,ny,min_path[ny][nx]
else:
que.append([nx,ny])
def getField():
matrix = []
first = input().strip()
H,W,N = list(map(int,first.split()))
for i in range(H):
row = list(input().strip())
for j in range(W):
if row[j].isdigit():
row[j] = int(row[j])
matrix.append(row)
return matrix,H,W,N
def getStart(field):
for y in range(len(field)):
for x in range(len(field[0])):
if field[y][x] == "S":
return x,y
def main():
matrix,H,W,N = getField()
sx,sy = getStart(matrix)
distance = 0
for k in range(N):
if k != 0:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,tmps[0],tmps[1],k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
else:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,sx,sy,k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
print(distance)
if __name__=='__main__':
main() | p00481 |
def bfs(field,H,W,start_x,start_y,tmp_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
que = []
que.append([start_x,start_y])
INF = 1000000
min_path = [[INF] * W for i in range(H)]
min_path[start_y][start_x] = 0
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < W and 0 <= ny < H and field[ny][nx] != "X" and min_path[ny][nx] == INF:
min_path[ny][nx] = min_path[current[1]][current[0]] + 1
if field[ny][nx] == tmp_N: # at the same cheese-power number
return nx,ny,min_path[ny][nx]
else:
que.append([nx,ny])
def getField():
matrix = []
first = input().strip()
H,W,N = list(map(int,first.split()))
for i in range(H):
row = list(input().strip())
for j in range(W):
if row[j].isdigit():
row[j] = int(row[j])
matrix.append(row)
return matrix,H,W,N
def getStart(field):
for y in range(len(field)):
for x in range(len(field[0])):
if field[y][x] == "S":
return x,y
def main():
matrix,H,W,N = getField()
sx,sy = getStart(matrix)
distance = 0
for k in range(N):
if k != 0:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,tmps[0],tmps[1],k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
else:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,sx,sy,k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
print(distance)
if __name__=='__main__':
main() | moves = [(0, -1), (0, 1), (-1, 0), (1, 0)]
def search(dataset):
min_time = 0
mouse = 1
gx, gy = get_start(dataset)
for i in range(N):
gx, gy, min_time_tmp = bfs(dataset, (gx, gy), mouse)
mouse += 1
min_time += min_time_tmp
print(min_time)
def bfs(dataset, start, mouse):
INF = 10000000
min_time = [[INF for j in range(W)] for i in range(H)]
min_time[start[0]][start[1]] = 0
queue = [start]
while len(queue) != 0:
dx, dy = queue.pop(0)
for i, j in moves:
nx = dx + i
ny = dy + j
if 0 <= nx < H and 0 <= ny < W and dataset[nx][ny] != 'X' and min_time[nx][ny] == INF:
cell = dataset[nx][ny]
else:
continue
if type(cell) is int:
if mouse == int(cell):
min_time[nx][ny] = min_time[dx][dy] + 1
return nx, ny, min_time[nx][ny]
min_time[nx][ny] = min_time[dx][dy] + 1
queue.append((nx, ny))
def get_start(dataset):
for i in range(H):
rows = dataset[i]
for j in range(W):
cell = rows[j]
if cell == 'S':
return i, j
dataset = []
while True:
line = input().rstrip().split()
if len(line) == 3:
H, W, N = list(map(int, line))
else:
row = []
for e in line[0]:
if e.isdigit():
row.append(int(e))
else:
row.append(e)
dataset.append(row)
if len(dataset) == H:
search(dataset)
break | p00481 |
def bfs(field,H,W,start_x,start_y,tmp_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
que = []
que.append([start_x,start_y])
INF = 1000000
min_path = [[INF] * W for i in range(H)]
min_path[start_y][start_x] = 0
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < W and 0 <= ny < H and field[ny][nx] != "X" and min_path[ny][nx] == INF:
min_path[ny][nx] = min_path[current[1]][current[0]] + 1
if field[ny][nx] == tmp_N: # at the same cheese-power number
return nx,ny,min_path[ny][nx]
else:
que.append([nx,ny])
def getField():
matrix = []
first = input().strip()
H,W,N = list(map(int,first.split()))
for i in range(H):
row = list(input().strip())
for j in range(W):
if row[j].isdigit():
row[j] = int(row[j])
matrix.append(row)
return matrix,H,W,N
def getStart(field):
for y in range(len(field)):
for x in range(len(field[0])):
if field[y][x] == "S":
return x,y
def main():
matrix,H,W,N = getField()
sx,sy = getStart(matrix)
distance = 0
for k in range(N):
if k != 0:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,tmps[0],tmps[1],k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
else:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,sx,sy,k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
print(distance)
if __name__=='__main__':
main() | def bfs(field,H,W,start_x,start_y,tmp_N):
direction = [[-1,0],[1,0],[0,-1],[0,1]]
que = []
que.append([start_x,start_y])
INF = 1000000
min_path = [[INF] * W for i in range(H)]
min_path[start_y][start_x] = 0
while len(que) != 0:
current = que.pop(0)
for d in direction:
nx = current[0] + d[0]
ny = current[1] + d[1]
if 0 <= nx < W and 0 <= ny < H and field[ny][nx] != "X" and min_path[ny][nx] == INF:
min_path[ny][nx] = min_path[current[1]][current[0]] + 1
if field[ny][nx] == tmp_N:
return nx,ny,min_path[ny][nx]
else:
que.append([nx,ny])
def getField():
matrix = []
first = input().strip()
H,W,N = list(map(int,first.split()))
for i in range(H):
row = list(input().strip())
for j in range(W):
if row[j].isdigit():
row[j] = int(row[j])
matrix.append(row)
return matrix,H,W,N
def getStart(field):
for y in range(len(field)):
for x in range(len(field[0])):
if field[y][x] == "S":
return x,y
def main():
matrix,H,W,N = getField()
sx,sy = getStart(matrix)
distance = 0
for k in range(N):
if k != 0:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,tmps[0],tmps[1],k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
else:
tmp_x,tmp_y,tmp_dist = bfs(matrix,H,W,sx,sy,k+1)
distance += tmp_dist
tmps = [tmp_x,tmp_y]
print(distance)
if __name__=='__main__':
main() | p00481 |
import sys
file_input = sys.stdin
H, W, N = list(map(int, file_input.readline().split()))
town_map = file_input.read()
start_index = town_map.index('S')
mouse = [start_index, 0]
# position, elapsed time
from collections import deque
for goal in range(1, N + 1):
q = deque()
unvisited = [True] * len(town_map)
unvisited[mouse[0]] = False
goal = str(goal)
while True:
cur_pos = mouse[0]
ew_pos = cur_pos % (W + 1)
if ew_pos < (W - 1):
next_pos = cur_pos + 1
lot = town_map[next_pos]
if lot != 'X' and unvisited[next_pos]:
if lot == goal:
mouse = [next_pos, mouse[1] + 1]
break
else:
m = [next_pos, mouse[1] + 1]
unvisited[next_pos] = False
q.append(m)
if ew_pos > 0:
next_pos = cur_pos - 1
lot = town_map[next_pos]
if lot != 'X' and unvisited[next_pos]:
if lot == goal:
mouse = [next_pos, mouse[1] + 1]
break
else:
m = [next_pos, mouse[1] + 1]
unvisited[next_pos] = False
q.append(m)
ns_pos = cur_pos // (W + 1)
if ns_pos < (H - 1):
next_pos = cur_pos + W + 1
lot = town_map[next_pos]
if lot != 'X' and unvisited[next_pos]:
if lot == goal:
mouse = [next_pos, mouse[1] + 1]
break
else:
m = [next_pos, mouse[1] + 1]
unvisited[next_pos] = False
q.append(m)
if ns_pos > 0:
next_pos = cur_pos - W - 1
lot = town_map[next_pos]
if lot != 'X' and unvisited[next_pos]:
if lot == goal:
mouse = [next_pos, mouse[1] + 1]
break
else:
m = [next_pos, mouse[1] + 1]
unvisited[next_pos] = False
q.append(m)
mouse = q.popleft()
print((mouse[1]))
| import sys
file_input = sys.stdin
H, W, N = list(map(int, file_input.readline().split()))
town_map = 'X' * (W + 2)
for line in file_input:
town_map += 'X' + line.rstrip() + 'X'
town_map += 'X' * (W + 2)
move = (1, -1, W + 2, -W - 2)
from collections import deque
def search(start_pos, goal_lot):
mouse = [start_pos, 0] # position, elapsed time
q = deque()
unvisited = [True] * len(town_map)
unvisited[start_pos] = False
goal_lot
while True:
cur_pos = mouse[0]
for d in move:
next_pos = cur_pos + d
lot = town_map[next_pos]
if lot != 'X' and unvisited[next_pos]:
if lot == goal_lot:
return (next_pos, mouse[1] + 1)
else:
m = [next_pos, mouse[1] + 1]
unvisited[next_pos] = False
q.append(m)
mouse = q.popleft()
def solve():
start_pos = town_map.find('S')
time = 0
for i in range(1, N + 1):
start_pos, t = search(start_pos, str(i))
time += t
print(time)
solve()
| p00481 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
import re
def check_out_of_map(pos,H,W):
H = len(Map)
W = len(Map[0])
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
r = re.compile("[0-9]")
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif r.match(char) is not None:
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos,H,W):
H = len(Map)
W = len(Map[0])
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif char.isnumeric():
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count) | p00481 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos,H,W):
H = len(Map)
W = len(Map[0])
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif char.isnumeric():
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos,H,W):
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif char.isnumeric():
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count) | p00481 |
def f(s):
s=list(map(int,s.split(':')))
return (s[0]*60+s[1])*60+s[2]
a=86401
while 1:
t=[0]*a
n=int(eval(input()))
if n==0:break
for _ in range(n):
b,c=input().split()
t[f(b)]+=1;t[f(c)]-=1
d=0
for i in range(1,a):
t[i]+=t[i-1]
d=max(d,t[i])
print(d) | def f(s):
return (s[0]*60+s[1])*60+s[2]
a=86400
while 1:
t=[0]*a
n=int(eval(input()))
if n==0:break
for _ in range(n):
b,c = [list(map(int,x.split(':'))) for x in input().split()]
t[f(b)]+=1;t[f(c)]-=1
d=0
for i in range(1,a):
t[i]+=t[i-1]
if d<t[i]:d=t[i]
print(d) | p01138 |
m=24*60*60
while True:
n=int(eval(input()))
if n==0:break
dp=[0]*(m+1)
for _ in range(n):
a,d=input().split()
a,b,c=list(map(int,a.split(':')));
d,e,f=list(map(int,d.split(':')));
dp[a*3600+b*60+c]+=1
dp[d*3600+e*60+f]-=1
for i in range(m):
dp[i+1]+=dp[i]
print((max(dp))) | m=24*60*60
while True:
n=int(input())
if n==0:break
dp=[0]*(m+1)
for _ in range(n):
a,d=input().split()
a,b,c=list(map(int,a.split(':')));
d,e,f=list(map(int,d.split(':')));
dp[a*3600+b*60+c]+=1
dp[d*3600+e*60+f]-=1
for i in range(m):
dp[i+1]+=dp[i]
print((max(dp))) | p01138 |
def tosec(t):
return int(t[:2])*60*60 + int(t[3:5])*60 + int(t[6:])
while True:
n = int(eval(input()))
if n == 0: break
time = [0] * (60*60*24 + 1)
for _ in range(n):
s, f = input().split()
time[tosec(s)] += 1
time[tosec(f)] -= 1
ans = time[0]
for i in range(60*60*24):
time[i+1] += time[i]
ans = max(ans, time[i+1])
print(ans) | while True:
n = eval(input())
if not n: break
time = [0]*86400
for i in range(n):
s, t = input().split()
ssec = int(s[0:2])*3600 + int(s[3:5])*60 + int(s[6:8])
tsec = int(t[0:2])*3600 + int(t[3:5])*60 + int(t[6:8])
time[ssec] += 1
time[tsec] -= 1
ans = time[0]
for i in range(86400-1):
time[i+1] += time[i]
ans = max(ans, time[i+1])
print(ans)
| p01138 |
import re
while True:
n = int(input())
if n == 0:
break
l = [0] * (24*60*60+1)
for _ in range(n):
h1,m1,s1,h2,m2,s2 = list(map(int, re.split(':| ', input())))
l[h1*60*60 + m1*60 + s1] += 1
l[h2*60*60 + m2*60 + s2] -= 1
r = 0
for i in range(24*60*60):
l[i+1] += l[i]
r = max(r, l[i+1])
print(r) | while True:
n = int(input())
if n == 0:
break
l = []
for _ in range(n):
hms1, hms2 = input().split()
l.append((hms1, True))
l.append((hms2, False))
l.sort()
r, t = 0, 0
for i in range(len(l)):
if l[i][1]:
t += 1
else:
t -= 1
r = max(r, t)
print(r) | p01138 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
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()]
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 input()
def pf(s): return print(s, flush=True)
def main():
global N, K, results
results = []
N, K = LI()
X = LI()
# すべて正にする
if N == 1 and K == 1 and X == [0]:
print(0)
return
min_x = min(X)
if min_x < 0:
X = [x - min_x for x in X]
# 貪欲的にいく？
dfs(-min_x, 0, X, 0, 0)
else:
dfs(0, 0, X, 0, 0)
print(min(results))
def dfs(p, s, rest, pidx, count):
global N, K, results
# 該当のものを使うか
# 右に行くか左に行くかの判断
# k個選んだら終了
if count == K:
results.append(s)
return
if rest[-1] < p:
# 右側には数字がない
dfs(rest[-1], s+p-rest[-1], rest[:-1], 0, count+1)
return
if rest[0] > p:
# 左側に数字がない
# K個選んで終わり
dfs(rest[0], s+rest[0] - p, rest[1:], 0, count+1)
return
if pidx == 0:
for ridx, r in enumerate(rest):
if r > p:
left = rest[ridx - 1]
new_rest = rest[:ridx-1] + rest[ridx:]
dfs(left, s + p - left, new_rest, ridx - 1, count+1)
right = r
new_rest = rest[:ridx] + rest[ridx+1:]
dfs(right, s + right - p, new_rest, ridx, count+1)
return
else:
left = rest[pidx - 1]
new_rest = rest[:pidx-1] + rest[pidx:]
dfs(left, s+p-left, new_rest, pidx - 1, count+1)
right = rest[pidx]
new_rest = rest[:pidx] + rest[pidx+1:]
dfs(right, s+right - p, new_rest, pidx, count+1)
if __name__ == "__main__":
main()
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
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()]
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 input()
def pf(s): return print(s, flush=True)
def main():
global N, K, results
global right_items, left_items, start_point
results = []
N, K = LI()
X = LI()
if K == 1 and X == [0]:
print(0)
return
if 0 in X:
X.remove(0)
K -= 1
N -= 1
if min(X) > 0:
# 右側しか見ない
print(max(X[:K]))
return
if max(X) < 0:
# 左側しかみない
print(abs(min(X[-K:])))
return
left_part = []
right_part = []
for i in X:
if i < 0:
left_part.append(abs(i))
else:
right_part.append(i)
left_part = left_part[::-1][:K]
right_part = right_part[:K]
result = 10**8
for i in range(0, K):
# left = d(left_part[:i], 0, 0)
if len(left_part[:i]) + len(right_part[:K-i]) != K:
continue
if len(left_part[:i]) == 0:
left_distance = 0
else:
left_distance = left_part[:i][-1]
# right = d(right_part[:K-i], 0, 0)
if len(right_part[:K-i]) == 0:
right_distance = 0
else:
right_distance = right_part[:K-i][-1]
# print('i, left, right', i, left, right)
# print('i, left, right', i, left_distance, right_distance)
# first = min(left, right)
# second = max(left, right)
first = min(left_distance, right_distance)
second = max(left_distance, right_distance)
# result = min(result, first*2+second)
result = min(result, first*2+second)
print(result)
# def d(arr, s, current_idx):
# if len(arr) == 0:
# return 0
# if len(arr) == 1:
# return arr[0]
# print(arr, s)
# if current_idx == 0:
# s += arr[0]
# return d(arr, s, current_idx + 1)
# if current_idx == len(arr) - 1:
# return s + arr[current_idx] - arr[current_idx - 1]
# s += arr[current_idx] - arr[current_idx - 1]
# return d(arr, s, current_idx + 1)
if __name__ == "__main__":
main()
| p03274 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
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()]
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 input()
def pf(s): return print(s, flush=True)
def main():
global N, K, results
global right_items, left_items, start_point
results = []
N, K = LI()
X = LI()
if K == 1 and X == [0]:
print(0)
return
if 0 in X:
X.remove(0)
K -= 1
N -= 1
if min(X) > 0:
# 右側しか見ない
print(max(X[:K]))
return
if max(X) < 0:
# 左側しかみない
print(abs(min(X[-K:])))
return
left_part = []
right_part = []
for i in X:
if i < 0:
left_part.append(abs(i))
else:
right_part.append(i)
left_part = left_part[::-1][:K]
right_part = right_part[:K]
result = 10**8
for i in range(0, K):
# left = d(left_part[:i], 0, 0)
if len(left_part[:i]) + len(right_part[:K-i]) != K:
continue
if len(left_part[:i]) == 0:
left_distance = 0
else:
left_distance = left_part[:i][-1]
# right = d(right_part[:K-i], 0, 0)
if len(right_part[:K-i]) == 0:
right_distance = 0
else:
right_distance = right_part[:K-i][-1]
# print('i, left, right', i, left, right)
# print('i, left, right', i, left_distance, right_distance)
# first = min(left, right)
# second = max(left, right)
first = min(left_distance, right_distance)
second = max(left_distance, right_distance)
# result = min(result, first*2+second)
result = min(result, first*2+second)
print(result)
# def d(arr, s, current_idx):
# if len(arr) == 0:
# return 0
# if len(arr) == 1:
# return arr[0]
# print(arr, s)
# if current_idx == 0:
# s += arr[0]
# return d(arr, s, current_idx + 1)
# if current_idx == len(arr) - 1:
# return s + arr[current_idx] - arr[current_idx - 1]
# s += arr[current_idx] - arr[current_idx - 1]
# return d(arr, s, current_idx + 1)
if __name__ == "__main__":
main()
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
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()]
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 input()
def pf(s): return print(s, flush=True)
N, K = LI()
X = LI()
if 0 in X:
X.remove(0)
K -= 1
if K == 0:
print(0)
exit()
# 累積和を使う
distances = []
mid = bisect.bisect_left(X, 0)
# print(mid)
# if mid == 0:
# # 正の数しかない
# distances = [0]
# for x in X:
# distances.append(distances[-1] + x)
# distances = distances[1:]
# else:
# # 負の数あり
# negs = [0]
# for x in X[:mid]:
# # 負の数を足して逆にする
# negs.append(negs[-1] + x)
# negs = negs[::-1][:-1]
# posi = [0]
# for x in X[mid:]:
# posi.append(posi[-1] + x)
# posi = posi[1:]
# distances = negs + posi
# from itertools import accumulate
# distances = list(accumulate(X))
for x in X:
if x < 0:
distances.append(-x)
else:
distances.append(x)
# print('dist', distances)
#左端から右にずれていく。
results = []
for start in range(N):
end = start + K
if end > N: break
# print('start, end', start, end)
# if end >= len(X): break
if start < mid < end:
# 飛び越える場合
results.append(min(distances[start], distances[end-1]) * 2 + max(distances[start], distances[end-1]))
elif start >= mid:
# 全部右側
results.append(distances[end-1])
else:
results.append(distances[start])
# print(results)
print(min(results))
| p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dis = 300000000
for i in range(N-K+1):
y = list(x[i:i+K])
disl = abs(x[i]) + abs(x[i+K-1]-x[i])
disr = abs(x[i+K-1]) + abs(x[i+K-1]-x[i])
dis = min(dis, disl, disr)
# if (y[0]*y[-1]<0):
# disy = y[-1]-y[0]+min(abs(y[-1]), abs(y[0]))
# else:
# disy = max(abs(y[0]), abs(y[-1]))
# dis = min(dis, disy)
print(dis) | N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dis = 300000000
for i in range(N-K+1):
disl = abs(x[i]) + abs(x[i+K-1]-x[i])
disr = abs(x[i+K-1]) + abs(x[i+K-1]-x[i])
dis = min(dis, disl, disr)
# if (y[0]*y[-1]<0):
# disy = y[-1]-y[0]+min(abs(y[-1]), abs(y[0]))
# else:
# disy = max(abs(y[0]), abs(y[-1]))
# dis = min(dis, disy)
print(dis) | p03274 |
def main():
# editorial読んだ．
N, K = list(map(int, input().split(" ")))
coordinates = list(map(int, input().split(" ")))
result = 10 ** 9 + 7
for i in range(N - K + 1):
result = min(result, abs(coordinates[i + K - 1] - coordinates[i]) + abs(coordinates[i]),
abs(coordinates[i + K - 1] - coordinates[i]) + abs(coordinates[i + K - 1]))
print(result)
if __name__ == '__main__':
main() | def main():
N, K = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
answer = 10 ** 9 + 7
for i in range(0, N - K + 1):
time = X[i + K - 1] - X[i] + min(abs(X[i]), abs(X[i + K - 1]))
answer = min(answer, time)
print(answer)
if __name__ == "__main__":
main() | p03274 |
def main():
n, k = list(map(int, input().split()))
x = [int(x) for x in input().split()]
answer = float("inf")
if 1 < n:
for i in range(n - k + 1):
if x[i + k - 1] < 0:
answer = min(answer, -x[i])
elif 0 < x[i]:
answer = min(answer, x[i + k - 1])
else:
answer = min(answer, min(abs(x[i]), abs(x[i + k - 1])) + x[i + k - 1] - x[i])
else:
answer = abs(x[0])
print(answer)
if __name__ == '__main__':
main()
| def main():
n, k = list(map(int, input().split()))
x = [int(i) for i in input().split()]
x.sort()
answer = float("inf")
if n == k:
if n == 1:
answer = abs(x[0])
if 0 <= x[0]:
answer = x[-1]
elif x[-1] <= 0:
answer = abs(x[0])
else:
answer = x[-1] - x[0] + min(abs(x[-1]), abs(x[0]))
else:
for i in range(n - k + 1):
left = x[i]
right = x[i + k - 1]
if left * right >= 0:
answer = min(answer, max(abs(left), abs(right)))
else:
answer = min(answer, right - left + min(abs(left), abs(right)))
print(answer)
if __name__ == '__main__':
main()
| p03274 |
N,K = list(map(int,input().split()))
ary = [0]+list(map(int,input().split()))
dp = [[0]*(N+1) for _ in range(N+1)]
ary = sorted(ary)
a = ary.index(0)
ans = float("Inf")
for i in range(N+1):
for j in range(N+1):
dp[i][j] = abs(ary[i]-ary[j])
for i in range(N+1):
if i == a:continue
k = abs(i - a)
d = abs(ary[i])
if k >= K and ans > d:
ans = d
if i <= a:
k = K - abs(i-a)
d = abs(ary[i])
if k > 0:
d += dp[i][a+k]
if ans > d:
ans = d
print((0 if ans == float("Inf") else ans)) | N, K = list(map(int, input().split()))
ary = [0] + list(map(int, input().split()))
ary = sorted(ary)
a = ary.index(0)
ans = float("Inf")
for i in range(N + 1):
if i == a: continue
k = abs(i - a)
d = abs(ary[i])
if k >= K and ans > d:
ans = d
if i < a:
k = K - abs(i - a)
d = abs(ary[i])
if 0 < k < len(ary[a:]):
d += abs(ary[i] - ary[k + a])
if ans > d:
ans = d
print((0 if ans == float("Inf") else ans))
| p03274 |
N, K = list(map(int, input().split()))
ary = [0] + list(map(int, input().split()))
ary.sort()
zero = ary.index(0)
a = [abs(i - zero) for i in range(N + 1)]
ary.pop(zero)
ans = float("Inf")
for i in range(N - K + 1):
b = N - i - 1
d = abs(ary[i])
if a[i] >= K:
ans = min(ans, d)
ans = min(ans, d + abs(ary[i] - ary[i + K - 1]))
d = abs(ary[b])
if a[b] >= K:
ans = min(ans, d)
ans = min(ans, d + abs(ary[b] - ary[b - K + 1]))
print(ans) | N, K = list(map(int, input().split()))
ary = list(map(int, input().split()))
ary2 = sorted(ary+[0])
zero = ary2.index(0)
k = [abs(i - zero) if i < zero else ((i + 1) - zero)for i in range(N)]
ans = float("Inf")
for i in range(N - K + 1):
if k[i] <= K:
if ans > abs(ary[i]) + abs(ary[i] - ary[i + (K - 1)]):
ans = abs(ary[i]) + abs(ary[i] - ary[i + (K - 1)])
for i in range(N-1, K-2, -1):
if k[i] <= K:
if ans > abs(ary[i]) + abs(ary[i] - ary[i - (K-1)]):
ans = abs(ary[i]) + abs(ary[i] - ary[i - (K-1)])
print(ans)
| p03274 |
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
tmp = [0] * k
ans = float("inf")
for i in range(n-k+1):
tmp = a[i:i+k]
if (tmp[0] <= 0 and tmp[-1] <= 0) or (tmp[0] >= 0 and tmp[-1] >= 0):
cost = max(abs(tmp[0]), abs(tmp[-1]))
else:
cost = min(abs(tmp[0]), abs(tmp[-1]))*2 + max(abs(tmp[0]), abs(tmp[-1]))
if ans > cost:
ans = cost
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):
#tmpの左端と右端の符号が同じなら、端から移動していく
if (a[i] <= 0 and a[i+k-1] <= 0) or (a[i] >= 0 and a[i+k-1] >= 0):
cost = max(abs(a[i]), abs(a[i+k-1]))
#選んだろうそくが正負にまたがる場合、左端と右端の近いほうに移動してから
else:
cost = min(abs(a[i]), abs(a[i+k-1]))*2 + max(abs(a[i]), abs(a[i+k-1]))
if ans > cost:
ans = cost
print(ans) | p03274 |
import sys, os, bisect
f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
sys.stdin = open('./input.txt', 'r')
def solve():
n , k = f()
a = f()
ans = int(1e10)
for i in range(n):
if i+k-1<n:
cur_ans = 0
if a[i]* a[i+k-1]>=0:
cur_ans = max(abs(a[i+k-1]),abs(a[i]))
else:
cur_ans = min(2*abs(a[i])+abs(a[i+k-1]), abs(a[i]) + 2*abs(a[i+k-1]))
ans = min(ans, cur_ans)
print(ans)
solve()
| import sys, os, bisect
f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
sys.stdin = open('./input.txt', 'r')
def solve():
n , k = f()
a = f()
ans = int(1e10)
for i in range(n):
if i+k-1<n:
ans = min(ans, abs(a[i]) + abs(a[i] - a[i+k-1]), abs(a[i+k-1]) + abs(a[i] - a[i+k-1]))
print(ans)
solve()
| p03274 |
def solve():
N, K = [int(i) for i in input().split()]
xlist = list(map(int, input().split()))
cost = float("inf")
for i in range(N-K+1):
j = i+K-1
cost = min(
abs(xlist[i])+abs(xlist[j]-xlist[i]),
abs(xlist[j])+abs(xlist[i]-xlist[j]),
cost
)
print(cost)
if __name__ == "__main__":
solve()
| def solve():
N, K = [int(i) for i in input().split()]
xlist = [int(i) for i in input().split()]
cost = float("inf")
for i in range(N-K+1):
j = i+K-1
cost = min(
cost,
abs(xlist[i])+abs(xlist[j]-xlist[i]),
abs(xlist[j])+abs(xlist[i]-xlist[j])
)
print(cost)
if __name__ == "__main__":
solve()
| p03274 |
N,k = list(map(int,input().split()))
a = list(map(int,input().split()))
i = 0
while i < N:
if a[i] >= 0:
break
i += 1
x = []
y = []
for j in range(i-k,i+1):
if j>=0 and j+k-1<N:
x = a[j:j+k]
if x[0] < 0 and x[k-1] > 0:
y.append(min(-x[0],x[k-1])*2 + max(-x[0],x[k-1]))
else:
y.append(max(-x[0],x[k-1]))
print((min(y))) | N, K = list(map(int,input().split()))
x = list(map(int,input().split()))
if 0 in x:
K -= 1
cand = []
hasleft = x[0] < 0
hasright = x[N-1] > 0
if K == 0:
cand = [0]
else:
for i in range(N-K+1):
left = x[i]
right = x[i+K-1]
if left < 0 and right > 0:
cand.append(min(abs(left)*2+right, right*2+abs(left)))
elif right < 0:
cand.append(abs(left))
elif left > 0:
cand.append(right)
print((min(cand))) | p03274 |
# ABC107C - Candles (ARC101C)
def main():
n, k = tuple(map(int, input().rstrip().split()))
x = tuple(map(int, input().rstrip().split()))
ans = float("inf")
for i in range(n - k + 1):
a, b = x[i], x[i + k - 1]
if a < b < 0 or 0 < a < b:
ans = min(ans, max(abs(a), abs(b)))
else:
ans = min(ans, max(abs(a), abs(b)) + min(abs(a), abs(b)) * 2)
print(ans)
if __name__ == "__main__":
main() | # ABC107C - Candles (ARC101C)
def main():
_, k = list(map(int, input().split()))
x = tuple(map(int, input().split()))
print((min(r - l + min(abs(l), abs(r)) for l, r in zip(x, x[k - 1 :]))))
if __name__ == "__main__":
main() | p03274 |
# ABC107C - Candles (ARC101C)
def main():
N, K, *X = list(map(int, open(0).read().split()))
ans = min(r - l + min(abs(l), abs(r)) for l, r in zip(X, X[K - 1 :]))
print(ans)
if __name__ == "__main__":
main() | # ABC107C - Candles (ARC101C)
def main():
N, K, *X = list(map(int, open(0).read().split()))
cand = [r - l + min(abs(l), abs(r)) for l, r in zip(X, X[K - 1 :])]
ans = min(cand)
print(ans)
if __name__ == "__main__":
main()
| p03274 |
n, k = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
INF = 10 ** 9
def sign(x):
return int(x >= 0)
ans = INF
for i in range(n - k + 1):
p = k + i - 1
if sign(x[i]) == sign(x[p]):
t = max(abs(x[i]), abs(x[p]))
else:
t = min(-x[i] * 2 + x[p], -x[i] + x[p] * 2)
if t < ans:
ans = t
print(ans) | n, k = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
INF = 10 ** 9
ans = INF
for li in range(n - k + 1):
ri = k + li - 1
t = min(abs(x[li]) + abs(x[ri] - x[li]), abs(x[ri]) + abs(x[li] - x[ri]))
ans = min(t, ans)
print(ans) | p03274 |
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = []
for i in range(n-k+1):
temp = a[i:i+k]
l = temp[0]
r = temp[-1]
dist_l = abs(l) + abs(l-r)
dist_r = abs(r) + abs(l-r)
dist = min(dist_l, dist_r)
b.append(dist)
print((min(b))) | n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = []
for i in range(n-k+1):
dist = a[i+k-1] - a[i] + min(abs(a[i]), abs(a[i+k-1]))
b.append(dist)
print((min(b))) | p03274 |
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = []
for i in range(n-k+1):
dist = a[i+k-1] - a[i] + min(abs(a[i]), abs(a[i+k-1]))
b.append(dist)
print((min(b))) | n, k = list(map(int, input().split()))
x = [int(i) for i in input().split()]
d = []
for i in range(n-k+1):
l, r = x[i], x[i+k-1]
d.append(abs(l-r) + min(abs(l), abs(r)))
print((min(d))) | p03274 |
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=10**9
for i in range(n-k+1):
d=x[i+k-1]-x[i]
d+=min(abs(x[i]),abs(x[i+k-1]))
ans=min(ans,d)
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):
x_max=x[i+k-1]
x_min=x[i]
t_ans=x_max-x_min
t_ans+=min(abs(x_max),abs(x_min))
ans=min(ans,t_ans)
print(ans) | p03274 |
import sys
input = sys.stdin.readline
def main():
N, K = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
plus = [0]
j = 0
for i in range(N):
if x[i] >= 0:
plus.append(x[i])
j += 1
j = 0
minus = [0]
for i in range(N - 1, -1, -1):
if x[i] < 0:
minus.append(x[i])
j += 1
ans = float("inf")
for i in range(0, K + 1):
if len(plus) - 1 < i:
continue
if len(minus) - 1 < K - i:
continue
rsum = plus[i]
lsum = abs(minus[K - i])
if rsum >= lsum:
ans = min(ans, rsum + lsum * 2)
else:
ans = min(ans, rsum * 2 + lsum)
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
N, K = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
ans = float("inf")
for i in range(N + 1 - K):
l = x[i]
r = x[i + K - 1]
if l < 0 < r:
ans = min(ans, abs(l) + abs(r) + min(abs(l), abs(r)))
else:
ans = min(ans, max(abs(l), abs(r)))
print(ans)
if __name__ == '__main__':
main()
| p03274 |
n, k = list(map(int,input().split()))
x = list(map(int,input().split()))
time = 10**9
for i in range(n - k + 1):
x_k = x[i:i+k]
#print(x_k)
if x_k[0] >= 0:
t = x_k[-1]
elif x_k[-1] <= 0:
t = -x_k[0]
else:
t = min(-x_k[0] + x_k[-1] *2,-x_k[0] * 2 + x_k[-1])
time = min(t, time)
print(time)
| n, k = list(map(int,input().split()))
x = list(map(int,input().split()))
time = 10**9
x_k = [0, 0]
for i in range(n - k + 1):
x_k[0] = x[i]
x_k[1] = x[i+k-1]
#print(x_k)
if x_k[0] >= 0:
t = x_k[1]
elif x_k[1] <= 0:
t = -x_k[0]
else:
t = min(-x_k[0] + x_k[1] *2,-x_k[0] * 2 + x_k[1])
time = min(t, time)
print(time)
| p03274 |
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
ans = 9999999999999
for i in range(len(l) - k + 1):
tl = l[i:i + k]
min_l = min(0, tl[0])
max_l = max(0, tl[-1])
min_abs = min(abs(min_l), abs(max_l))
max_abs = max(abs(min_l), abs(max_l))
ans = min(ans, min_abs * 2 + max_abs)
print(ans) | n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
ans = 9999999999999
for i in range(len(l) - k + 1):
min_l = min(0, l[i])
max_l = max(0, l[i+k-1])
min_abs = min(abs(min_l), abs(max_l))
max_abs = max(abs(min_l), abs(max_l))
ans = min(ans, min_abs * 2 + max_abs)
print(ans) | p03274 |
def main():
n, k, *x = list(map(int, open(0).read().split()))
f = lambda i: x[i + k - 1] - x[i] + min(abs(x[i + k - 1]), abs(x[i]))
l = f(0)
for i in range(n - k + 1):
y = f(i)
if y < l:
l = y
print(l)
if __name__ == '__main__':
main()
| def main():
n, k, *x = list(map(int, open(0).read().split()))
l = x[0 + k - 1] - x[0] + min(abs(x[0 + k - 1]), abs(x[0]))
for i in range(n - k + 1):
y = x[i + k - 1] - x[i] + min(abs(x[i + k - 1]), abs(x[i]))
if y < l:
l = y
print(l)
if __name__ == '__main__':
main()
| p03274 |
n,k,*x=list(map(int,open(0).read().split()))
if x[0]>=0:
ans=x[k-1]
elif x[-1]<=0:
ans=abs(x[~(k-1)])
elif n==k:
l=abs(x[0])
r=abs(x[-1])
ans=min(l+l+r,r+r+l)
else:
ans=10**10
for i in range(n-k+1):
l=x[i]
r=x[i+k-1]
if l<=0<=r:
ll=abs(l)
rr=abs(r)
tmp=min(ll+2*rr,2*ll+rr)
ans=min(ans,tmp)
print(ans)
| n,k,*x=list(map(int,open(0).read().split()))
if x[0]>=0:
ans=x[k-1]
elif x[-1]<=0:
ans=abs(x[~(k-1)])
else:
ans=10**10
for i in range(n-k+1):
l=x[i]
r=x[i+k-1]
if l<=0<=r:
ll=abs(l)
rr=abs(r)
tmp=min(ll+2*rr,2*ll+rr)
ans=min(ans,tmp)
print(ans)
| p03274 |
import sys
from bisect import bisect_left as bl
input = sys.stdin.readline
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [float("inf")] * (K + 2)
s = bl(x, 0)
l = 0
r = K - 1
if r + 1 < s:
l = s - 1 - r
r = s - 1
def calc(l, r):
if x[l] * x[r] < 0:
return min(abs(x[l]), abs(x[r])) * 2 + max(abs(x[l]), abs(x[r]))
else:
return max(abs(x[l]), abs(x[r]))
dp[0] = calc(l, r)
for i in range(1, K + 2):
l += 1
r += 1
if l > s + 1 or r >= N:
break
dp[i] = calc(l, r)
print((min(dp))) | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
res = float("inf")
for i in range(N - K + 1):
if a[i] * a[i + K - 1] < 0:
mn = min(abs(a[i]), abs(a[i + K - 1]))
mx = max(abs(a[i]), abs(a[i + K - 1]))
res = min(res, mn * 2 + mx)
else:
res = min(res, max(abs(a[i]), abs(a[i + K - 1])))
print(res) | p03274 |
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
res = float("inf")
for i in range(N - K + 1):
if a[i] * a[i + K - 1] < 0:
mn = min(abs(a[i]), abs(a[i + K - 1]))
mx = max(abs(a[i]), abs(a[i + K - 1]))
res = min(res, mn * 2 + mx)
else:
res = min(res, max(abs(a[i]), abs(a[i + K - 1])))
print(res) | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
z = -1
res = float("inf")
for r in range(N):
if a[r] < 0:
z = r
continue
if r < K - 1: continue
x = r - z
y = a[z - (K - x) + 1]
if K == x: y = 0
t = min(abs(a[r]), abs(y))
if r - z >= K: t = 0
res = min(res, abs(a[r]) + abs(y) + t)
for l in range(N):
if z - l + 1 == K:
res = min(res, abs(a[l]))
break
print(res) | p03274 |
n,k=list(map(int,input().split()))
candles=list(map(int,input().split()))
rows=[]
minimum=[]
for i in range(n-k+1):
new=candles[i:i+k]
l_r=abs(new[0])+abs(new[-1]-new[0])
r_l=abs(new[-1])+abs(new[-1]-new[0])
minimum.append(min(l_r,r_l))
print((min(minimum))) | N, K, *x = list(map(int, open(0).read().split()))
ans = 1e9
for i in range(N - K + 1):
l = x[i]
r = x[i + K - 1]
ans = min(ans, abs(l) + (r - l), abs(r) + (r - l))
print(ans) | p03274 |
###############################################################################
from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
mod = 1
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * y) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def combination(x, y):
assert(x >= y)
if y > x // 2:
y = x - y
ret = 1
for i in range(0, y):
j = x - i
i = i + 1
ret = ret * j
ret = ret // i
return ret
def get_divisors(x):
retlist = []
for i in range(1, int(x**0.5) + 3):
if x % i == 0:
retlist.append(i)
retlist.append(x // i)
return retlist
def get_factors(x):
retlist = []
for i in range(2, int(x**0.5) + 3):
while x % i == 0:
retlist.append(i)
x = x // i
retlist.append(x)
return retlist
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = []
vlist = [v]
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = []
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next.extend(linklist[v])
distance += 1
vlist_to_del = vlist_previous
vlist_previous = vlist
vlist = list(set(vlist_next) - set(vlist_to_del))
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
###############################################################################
def calc_cost(plist):
if len(plist) == 0:
return 0
if len(plist) == 1:
return abs(plist[0])
if plist[0] >= 0:
return plist[-1]
if plist[-1] <= 0:
return abs(plist[0])
right_cost = plist[-1]
left_cost = abs(plist[0])
return min(right_cost, left_cost) * 2 + max(right_cost, left_cost)
def main():
n, k = intin()
xlist = intina()
min_cost = calc_cost(xlist)
for i in range(n - k):
min_cost = min(calc_cost(xlist[i:(i+k)]), min_cost)
print(min_cost)
if __name__ == '__main__':
main()
| ###############################################################################
from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
mod = 1
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * y) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def combination(x, y):
assert(x >= y)
if y > x // 2:
y = x - y
ret = 1
for i in range(0, y):
j = x - i
i = i + 1
ret = ret * j
ret = ret // i
return ret
def get_divisors(x):
retlist = []
for i in range(1, int(x**0.5) + 3):
if x % i == 0:
retlist.append(i)
retlist.append(x // i)
return retlist
def get_factors(x):
retlist = []
for i in range(2, int(x**0.5) + 3):
while x % i == 0:
retlist.append(i)
x = x // i
retlist.append(x)
return retlist
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = []
vlist = [v]
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = []
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next.extend(linklist[v])
distance += 1
vlist_to_del = vlist_previous
vlist_previous = vlist
vlist = list(set(vlist_next) - set(vlist_to_del))
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
###############################################################################
def calc_cost(plist, left, right):
if left == right:
return abs(plist[left])
if plist[left] >= 0:
return plist[right]
if plist[right] <= 0:
return abs(plist[left])
left_cost = abs(plist[left])
right_cost = plist[right]
return min(left_cost, right_cost) * 2 + max(left_cost, right_cost)
def main():
n, k = intin()
xlist = intina()
min_cost = float('inf')
for i in range(n - k + 1):
min_cost = min(calc_cost(xlist, i, i + k - 1), min_cost)
print(min_cost)
if __name__ == '__main__':
main()
| p03274 |
import sys
input = sys.stdin.readline
N,K = list(map(int,input().split()))
X = list(map(int,input().split()))
ans = 10**9
for i in range(N-K+1):
#print(X[i:i+K])
if min(X[i:i+K]) >= 0:
#print('a')
ans = min(ans,max(X[i:i+K]))
elif max(X[i:i+K]) <= 0:
#print('b')
ans = min(ans,abs(min(X[i:i+K])))
else:
#print('c')
ans = min(ans,abs(min(X[i:i+K])*2)+max(X[i:i+K]))
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):
ans = min(ans,X[i+K-1]-X[i]+min(abs(X[i]),abs(X[i+K-1])))
print(ans) | p03274 |
n,k = list(map(int,input().split()))
x = [int(x) for x in input().split()]
mini = 10**9
for i in range(n-k+1):
ls = x[i:i+k]
flg1 = abs(ls[0])+abs(ls[0]-ls[k-1])
flg2 = abs(ls[k-1])+abs(ls[0]-ls[k-1])
flg = min(flg1,flg2)
mini = min(flg,mini)
print(mini) | n,k = list(map(int,input().split()))
ls = [int(x) for x in input().split()]
mini = 10**9
for i in range(n-k+1):
flg1 = abs(ls[i])+abs(ls[i]-ls[i+k-1])
flg2 = abs(ls[i+k-1])+abs(ls[i]-ls[i+k-1])
mini = min(flg1,flg2,mini)
print(mini) | p03274 |
def solve():
n, k = list(map(int, input().split()))
xs = list(map(int, input().split()))
min_dist = 10 ** 9
for i in range(n - k + 1):
part = xs[i:i + k]
length = abs(part[0] - part[-1])
dist = min(abs(part[0]) + length, abs(part[-1]) + length)
if dist < min_dist:
min_dist = dist
return min_dist
if __name__ == "__main__":
print((solve()))
| def solve():
n, k = list(map(int, input().split()))
xs = list(map(int, input().split()))
min_dist = 10 ** 9
for i in range(n - k + 1):
length = abs(xs[i] - xs[i + k - 1])
dist = min(abs(xs[i]) + length, abs(xs[i + k - 1]) + length)
if dist < min_dist:
min_dist = dist
return min_dist
if __name__ == "__main__":
print((solve()))
| p03274 |
import sys
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: [int(x) for x in ns().split()]
nall = lambda: [int(x) for x in sys.stdin.readlines()]
sall = lambda: sys.stdin.readlines()
def main():
n, k = na()
xs = na()
m = float('inf')
for i in range(n-k+1):
vs = xs[i:i+k]
if vs[0] * vs[-1] < 0:
l = abs(vs[0]) + abs(vs[-1]) + min(abs(vs[0]), abs(vs[-1]))
else:
l = max(abs(vs[0]), abs(vs[-1]))
m = min(m, l)
print(m)
main()
| import sys
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: [int(x) for x in ns().split()]
nall = lambda: [int(x) for x in sys.stdin.readlines()]
sall = lambda: sys.stdin.readlines()
def main():
n, k = na()
xs = na()
m = float('inf')
for i in range(n-k+1):
if xs[i] * xs[i+k-1] < 0:
l = abs(xs[i]) + abs(xs[i+k-1]) + min(abs(xs[i]), abs(xs[i+k-1]))
else:
l = max(abs(xs[i]), abs(xs[i+k-1]))
m = min(m, l)
print(m)
main()
| p03274 |
n,k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = float("inf")
for i in range(n-k+1):
# 0の位置から移動し、i〜i+kまでのろうそくに火をつけた場合の移動時間について左右で確認し、最小を求める
l = abs(x[i]) + abs(x[i]-x[i+k-1])
r = abs(x[i+k-1]) + abs(x[i] - x[i+k-1])
ans = min(ans, l, r)
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 = abs(x[i]) + abs(x[i]-x[i+k-1])
r = abs(x[n-1-i]) + (x[n-1-i]-x[n-k-i])
ans = min(ans,l,r)
print(ans) | p03274 |
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
xi = list(map(int, input().split()))
kouho = []
ans_list = []
for i in range(N-K+1):
li = xi[i:i+K]
if li[0]*li[-1] < 0:
a = abs(li[0])*2 + abs(li[-1])
b = abs(li[-1])*2 + abs(li[0])
if a > b :
ans_list.append(b)
else:
ans_list.append(a)
elif li[0] < 0:
ans_list.append(abs(li[0]))
else: #if li[-1] > 0:
ans_list.append(abs(li[-1]))
print((min(ans_list)))
| # -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
xi = list(map(int, input().split()))
ans_list = []
for i in range(N-K+1):
l = xi[i]
r = xi[i+K-1]
if l*r < 0:
a = abs(l)*2 + abs(r)
b = abs(r)*2 + abs(l)
if a > b :
ans_list.append(b)
else:
ans_list.append(a)
elif l < 0:
ans_list.append(abs(l))
else: #if li[-1] > 0:
ans_list.append(abs(r))
print((min(ans_list)))
| p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
if N == 1:
print((abs(X[0])))
exit()
flg = False
for x in X:
if x < 0:
flg = True
if flg is False:
print((X[K - 1]))
exit()
flag2 = False
for x in X:
if x > 0:
flag2 = True
if flag2 is False:
X.reverse()
print((abs(X[K - 1])))
exit()
def sol(lft, rgt):
if X[lft] < 0 and X[rgt] < 0:
return float('inf')
elif X[lft] <= 0:
return min(2 * abs(X[lft]) + X[rgt], abs(X[lft]) + 2 * X[rgt])
else:
return float('inf')
lft, rgt = 0, 0
ans = float('inf')
while True:
if rgt == N - 1:
break
if rgt - lft + 1 < K:
rgt += 1
if rgt - lft + 1 == K:
ans = min(ans, sol(lft, rgt))
lft += 1
print(ans)
| N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
lft, rgt = 0, K - 1
ans = float('inf')
while True:
if rgt == N:
break
ans = min(ans, min(abs(X[lft]) + abs(X[lft] - X[rgt]),
abs(X[rgt]) + abs(X[rgt] - X[lft])))
lft += 1
rgt += 1
print(ans)
| p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
assert len(x) == N
m = min(x[i] - x[i-K+1] + min(abs(x[i]), abs(x[i-K+1])) for i in range(K-1, N))
print(m) | N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
assert len(x) == N
m = min(b - a + min(abs(a), abs(b)) for a, b in zip(x, x[K-1:]))
print(m) | p03274 |
N, K = list(map(int, input().split()))
cans = list(map(int, input().split()))
d = []
for n in range(N-K+1):
l = abs(cans[n]) + abs(cans[n + (K-1)] - cans[n])
r = abs(cans[n + (K-1)]) + abs(cans[n + (K-1)] - cans[n])
d.append(min(l,r))
print((min(d))) | N, K = list(map(int, input().split()))
cans = list(map(int, input().split()))
print((min([min(abs(cans[n]), abs(cans[n + (K-1)])) + abs(cans[n + (K-1)] - cans[n]) for n in range(N-K+1)]))) | p03274 |
n, k, *a = list(map(int, open(0).read().split()))
ans = 1e11
for i in range(n-k+1):
ans = min(ans, a[i+k-1]-a[i]+min(abs(a[i+k-1]),abs(a[i])))
print(ans) | n,k,*a=list(map(int,open(0).read().split()));print((min([a[i+k-1]-a[i]+min(abs(a[i+k-1]),abs(a[i]))for i in range(n-k+1)]))) | p03274 |
import sys
def input(): return sys.stdin.readline().rstrip()
def solve(l, m):
if l < m:
return l * 2 + m
else:
return l + m * 2
def main():
N, K = list(map(int, input().split()))
x = tuple(map(int, input().split()))
right_x = [i for i in x if i >= 0][:K]
left_x = [-i for i in x if i < 0][-K:]
left_len = len(left_x)
right_len = len(right_x)
if right_len < K:
right_x += [10 ** 9 + 1] * (K - right_len)
if left_len < K:
left_x = [10 ** 9 + 1] * (K - left_len) + left_x
right_x = [0] + right_x
left_x += [0]
ans = 10 ** 9
for i in range(K + 1):
tmp_ans = solve(left_x[i], right_x[i])
if tmp_ans < ans:
ans = tmp_ans
print(ans)
if __name__ == '__main__':
main()
| import sys
def input(): return sys.stdin.readline().rstrip()
def solve(l, r):
lv = abs(l)
rv = abs(r)
if (l < 0) ^ (r < 0):
return lv + rv + min(lv, rv)
else:
return max(lv, rv)
def main():
N, K = list(map(int, input().split()))
x = tuple(map(int, input().split()))
ans = 10 ** 9
for i in range(N - K + 1):
tmp_ans = solve(x[i], x[i + K - 1])
if tmp_ans < ans:
ans = tmp_ans
print(ans)
if __name__ == '__main__':
main()
| p03274 |
import sys
n, k, *x = list(map(int, sys.stdin.read().split()))
def main():
l = 0; r = k - 1
ans = float('inf')
while r < n:
if x[r] <= 0:
res = abs(x[l])
elif x[l] < 0:
res = min(abs(x[l]), x[r]) * 2 + max(abs(x[l]), x[r])
else:
res = x[r]
ans = min(ans, res)
l += 1; r += 1
return ans
if __name__ == '__main__':
ans = main()
print(ans) | import sys
n, k, *x = list(map(int, sys.stdin.read().split()))
def main():
res = float('inf')
for i in range(n - k + 1):
j = i + k - 1
if x[i] < 0:
d = -x[i] if x[j] <= 0 else min(-x[i], x[j]) * 2 + max(-x[i], x[j])
else:
d = x[j]
res = min(res, d)
print(res)
if __name__ == '__main__':
main() | p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
cost = []
for i in range(0, N-K+1):
window = X[i:i+K]
cost.append(window[-1]-window[0] + min(abs(window[-1]), abs(window[0])))
print((min(cost))) | N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
cost = []
for i in range(0, N-K+1):
#window = X[i:i+K]
#cost.append(window[-1]-window[0] + min(abs(window[-1]), abs(window[0])))
cost.append(X[i+K-1]-X[i] + min(abs(X[i+K-1]), abs(X[i])))
print((min(cost))) | p03274 |
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in sys.stdin.readline().split()]
def gcd(n, m):
if n % m == 0:
return m
else:
return gcd(m, n % m)
def gcd_list(L):
v = L[0]
for i in range(1, len(L)):
v = gcd(v, L[i])
return v
def lcm(n, m):
return (n * m) // gcd(n, m)
def lcm_list(L):
v = L[0]
for i in range(1, len(L)):
v = lcm(v, L[i])
return v
# Width First Search (+ Distance)
def wfs_d(D, N, K):
"""
D: 隣接行列(距離付き)
N: ノード数
K: 始点ノード
"""
dfk = [-1] * (N + 1)
dfk[K] = 0
cps = [(K, 0)]
r = [False] * (N + 1)
r[K] = True
while len(cps) != 0:
n_cps = []
for cp, cd in cps:
for i, dfcp in enumerate(D[cp]):
if dfcp != -1 and not r[i]:
dfk[i] = cd + dfcp
n_cps.append((i, cd + dfcp))
r[i] = True
cps = n_cps[:]
return dfk
# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
"""
v: 現在のノード
pre: １つ前のノード
dist: 現在の距離
以下は別途用意する
D: 隣接リスト(行列ではない)
D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
"""
global D
global D_dfs_d
D_dfs_d[v] = dist
for next_v, d in D[v]:
if next_v != pre:
dfs_d(next_v, v, dist + d)
return
def sigma(N):
ans = 0
for i in range(1, N + 1):
ans += i
return ans
def comb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def bisearch(L, target):
low = 0
high = len(L) - 1
while low <= high:
mid = (low + high) // 2
guess = L[mid]
if guess == target:
return True
elif guess < target:
low = mid + 1
elif guess > target:
high = mid - 1
if guess != target:
return False
# --------------------------------------------
dp = None
def main():
N, K = li_input()
A = li_input()
Ps, Ng = [], []
for a in A:
if a > 0:
Ps.append(a)
else:
Ng.append((-1) * a)
Ps.sort()
Ng.sort()
ans = 10**20
# goto right
if len(Ps):
for turn in range(K-len(Ng)-1, min(K, len(Ps))):
dist = Ps[turn]
if turn != K - 1:
dist += Ps[turn] + Ng[K - turn - 2]
if dist < ans:
ans = dist
# goto left
if len(Ng):
for turn in range(K-len(Ps)-1, min(K, len(Ng))):
dist = Ng[turn]
if turn != K - 1:
dist += Ng[turn] + Ps[K - turn - 2]
if dist < ans:
ans = dist
print(ans)
main()
| import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(1000000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in sys.stdin.readline().split()]
def gcd(n, m):
if n % m == 0:
return m
else:
return gcd(m, n % m)
def gcd_list(L):
v = L[0]
for i in range(1, len(L)):
v = gcd(v, L[i])
return v
def lcm(n, m):
return (n * m) // gcd(n, m)
def lcm_list(L):
v = L[0]
for i in range(1, len(L)):
v = lcm(v, L[i])
return v
# Width First Search (+ Distance)
def wfs_d(D, N, K):
"""
D: 隣接行列(距離付き)
N: ノード数
K: 始点ノード
"""
dfk = [-1] * (N + 1)
dfk[K] = 0
cps = [(K, 0)]
r = [False] * (N + 1)
r[K] = True
while len(cps) != 0:
n_cps = []
for cp, cd in cps:
for i, dfcp in enumerate(D[cp]):
if dfcp != -1 and not r[i]:
dfk[i] = cd + dfcp
n_cps.append((i, cd + dfcp))
r[i] = True
cps = n_cps[:]
return dfk
# Depth First Search (+Distance)
def dfs_d(v, pre, dist):
"""
v: 現在のノード
pre: １つ前のノード
dist: 現在の距離
以下は別途用意する
D: 隣接リスト(行列ではない)
D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
"""
global D
global D_dfs_d
D_dfs_d[v] = dist
for next_v, d in D[v]:
if next_v != pre:
dfs_d(next_v, v, dist + d)
return
def sigma(N):
ans = 0
for i in range(1, N + 1):
ans += i
return ans
def comb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def bisearch(L, target):
low = 0
high = len(L) - 1
while low <= high:
mid = (low + high) // 2
guess = L[mid]
if guess == target:
return True
elif guess < target:
low = mid + 1
elif guess > target:
high = mid - 1
if guess != target:
return False
# --------------------------------------------
dp = None
def main():
N, K = li_input()
A = li_input()
D = []
for i in range(N - K + 1):
l,r = A[i],A[i+K-1]
D.append(min(abs(l) + abs(r - l), abs(r) + abs(r - l)))
print((min(D)))
main()
| p03274 |
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
ans=float('inf')
for i in range(n-k+1):
nowx=x[i:i+k]
if nowx[0]>=0 and nowx[-1]>=0:
ans=min(ans, nowx[-1])
elif nowx[0]<=0 and nowx[-1]<=0:
ans=min(ans, abs(nowx[0]))
elif nowx[0]<0 and nowx[-1]>=0:
ans=min(ans, 2*abs(nowx[0])+nowx[-1], abs(nowx[0])+2*nowx[-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):
nowx=(x[i],x[i+k-1])
if nowx[0]>=0 and nowx[-1]>=0:
ans=min(ans, nowx[-1])
elif nowx[0]<=0 and nowx[-1]<=0:
ans=min(ans, abs(nowx[0]))
elif nowx[0]<0 and nowx[-1]>=0:
ans=min(ans, 2*abs(nowx[0])+nowx[-1], abs(nowx[0])+2*nowx[-1])
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n-k+1):
xtmp = x[i:i+k]
if i==0:
MIN = abs(xtmp[0]-xtmp[-1]) + abs(xtmp[0])
MIN = min(MIN, abs(xtmp[0]-xtmp[-1]) + abs(xtmp[0]))
MIN = min(MIN, abs(xtmp[0]-xtmp[-1]) + abs(xtmp[-1]))
print(MIN) | # -*- coding: utf-8 -*-
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(left-right), abs(right)+abs(right-left))
print(ans)
| p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
arr = []
for i in range(n-k+1):
arr.append(min((abs(x[i])+abs(x[i]-x[i+k-1])), abs(x[i+k-1])+abs(x[i]-x[i+k-1])))
print((min(arr)))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()
N, K = i_l()
x = i_l()
ans = 1 << 31
for i in range(N-K+1):
if x[i] >= 0:
ans = min(ans, x[i+K-1])
elif x[i+K-1] <= 0:
ans = min(ans, abs(x[i]))
elif x[i] <= 0 and 0 <= x[i+K-1]:
ans = min(ans, x[i+K-1] - x[i] + min(abs(x[i+K-1]), abs(x[i])))
print(ans) | p03274 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
x = LIST()
ans = INF
idx = bisect(x, 0)
for i in range(idx-K, idx+1):
if 0 <= i <= N-K:
l = x[i:i+K]
if i == idx-K:
ans = min(ans, abs(x[i]))
elif i == idx:
ans = min(ans, x[i+K-1])
else:
ans = min(ans, 2*abs(x[i])+x[i+K-1], abs(x[i])+2*x[i+K-1])
print(ans)
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
x = LIST()
ans = INF
idx = bisect(x, 0)
for i in range(idx-K, idx+1):
if 0 <= i <= N-K:
if i == idx-K:
ans = min(ans, abs(x[i]))
elif i == idx:
ans = min(ans, x[i+K-1])
else:
ans = min(ans, 2*abs(x[i])+x[i+K-1], abs(x[i])+2*x[i+K-1])
print(ans)
| p03274 |
import bisect
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans, tmp = 10**9, 10**9
#print(bisect.bisect(x, 0))
for i in range(len(x) - K + 1):
if x[i] <= 0 and x[i+K-1] >= 0:
tmp = abs(x[i]) + x[i+K-1] + min(abs(x[i]), x[i+K-1])
elif x[i] < 0 and x[i+K-1] <= 0:
tmp = abs(x[i])
elif x[i] >= 0 and x[i+K-1] > 0:
tmp = x[i+K-1]
# elif i == bisect.bisect(x, 0)-1:
# tmp = x[i+K-1]
# elif i+K-1 == bisect.bisect(x, 0)-1:
# tmp = abs[x[i]]
# print("i:{}, i+K-1:{}, tmp:{}".format(i, i+K-1, tmp))
ans = min(tmp, ans)
print(ans) | N, K = list(map(int, input().split()))
x = [int(i) for i in input().split()]
ans = 10**9
for l in range(N-K+1):
r = l + K - 1
tmp = x[r]-x[l]
if x[r] < 0:
tmp += abs(x[r])
elif x[l] < 0 and 0 <= x[r]:
tmp += min(abs(x[l]), x[r])
else:
tmp += x[l]
ans = min(ans, tmp)
print(ans) | p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
answer = []
for i in range(N):
if i + K > N:
break
Y = X[i:i+K]
if Y[0] > 0:
answer.append(Y[-1])
elif Y[-1] < 0:
answer.append(-Y[0])
else:
answer.append(min(Y[0]*(-2)+Y[-1], Y[-1]*2-Y[0]))
print((min(answer))) | N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
answer = []
for i in range(N):
if i + K > N:
break
Ys, Yt = X[i], X[i+K-1]
if Ys > 0:
answer.append(Yt)
elif Yt < 0:
answer.append(-Ys)
else:
answer.append(min(Ys*(-2)+Yt, Yt*2-Ys))
print((min(answer))) | p03274 |
def solve(N, K, Xs):
plus = sorted([x for x in Xs if x >= 0])
minus = sorted([abs(x) for x in Xs if x < 0])
ans = 10 ** 9
for i in range(0, max(K, len(plus)) + 1):
ps = plus[:i]
ms = minus[:K - i]
if len(ps) == K:
ans = min(ans, ps[-1])
continue
if len(ms) == K:
ans = min(ans, ms[-1])
continue
if len(ps) + len(ms) == K:
p, m = ps[-1], ms[-1]
ans = min(ans, p * 2 + m, m * 2 + p)
return ans
if __name__ == "__main__":
N, K = tuple(map(int, input().split(" ")))
Xs = list(map(int, input().split(" ")))
print((solve(N, K, Xs)))
| def solve(N, K, Xs):
plus = sorted([x for x in Xs if x >= 0])
minus = sorted([abs(x) for x in Xs if x < 0])
ans = 10 ** 9
for i in range(0, K + 1):
j = K - i
if i <= len(plus) and i == K:
p = plus[i-1]
ans = min(ans, p)
elif j <= len(minus) and j == K:
m = minus[j-1]
ans = min(ans, m)
elif i <= len(plus) and j <= len(minus):
p = plus[i - 1]
m = minus[j - 1]
ans = min(ans, p * 2 + m, m * 2 + p)
return ans
if __name__ == "__main__":
N, K = tuple(map(int, input().split(" ")))
Xs = list(map(int, input().split(" ")))
print((solve(N, K, Xs)))
| p03274 |
N,K = list(map(int, input().split()))
X = []
idx = 0
for i,x in enumerate(input().split()):
x = int(x)
X.append(x)
if x < 0:
idx = i + 1
if idx == N:
idx = N-1
ans = 10**9
for i in range(max(0,idx-K), min(N-K+1,idx+K)):
tmp = 0
if i <= idx <= i+K-1 or i >= idx or i+K-1 <= idx:
tmp = min(abs(X[i]), abs(X[i+K-1]))
# print(i,tmp)
ans = min(ans, X[i+K-1] - X[i] + tmp)
print(ans) | N,K = list(map(int, input().split()))
X = []
idx = 0
for i,x in enumerate(input().split()):
x = int(x)
X.append(x)
if x < 0:
idx = i + 1
if idx == N:
idx = N-1
ans = 10**9
for i in range(max(0,idx-K), min(N-K+1,idx+K)):
ans = min(ans, X[i+K-1] - X[i] + min(abs(X[i]), abs(X[i+K-1])))
print(ans) | p03274 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
first = True
for l, r in zip(list(range(0, n - k + 1)), list(range(k - 1, n))):
if 0 >= x[r]:
if first:
min_time = -x[l]
first = False
else:
time =-x[l]
if time < min_time:
min_time = time
elif 0 <= x[l]:
if first:
min_time = x[r]
first = False
else:
time = x[r]
if time < min_time:
min_time = time
else:
if first:
min_time = (x[r] - x[l]) + min(-x[l], x[r])
first = False
else:
time = 2 * (x[r] - x[l]) - max(-x[l], x[r])
if time < min_time:
min_time = time
print(min_time) | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
min_time = 10 ** 10
for l, r in zip(list(range(0, n - k + 1)), list(range(k - 1, n))):
time = x[r] if x[l] >= 0 else (-x[l] if x[r] <= 0 else (x[r] - x[l]) + min(-x[l], x[r]))
if time < min_time:
min_time = time
print(min_time) | p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**18
for i in range(N-K+1):
y = x[i:i+K]
y0 = x[i]
yk = x[i+K-1]
if yk < 0:
ans = min(ans, abs(y0))
elif y0 <= 0 and 0 <= yk:
ans = min(ans, yk-2*y0, 2*yk-y0)
else:
ans = min(ans, yk)
print(ans)
| N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**18
for i in range(N-K+1):
y0 = x[i]
yk = x[i+K-1]
if yk < 0:
ans = min(ans, abs(y0))
elif y0 <= 0 and 0 <= yk:
ans = min(ans, yk-2*y0, 2*yk-y0)
else:
ans = min(ans, yk)
print(ans)
| p03274 |
def main():
N, K = (int(i)for i in input().split())
x = [int(i) for i in input().split()]
ans = 3 * (10**8)
st_val = min(x,key=abs)
st_idx = x.index(st_val)
for i in range(K+1):
dist = 3 * (10**8)
if 0 <= st_idx-K+1+i and st_idx+1+i <= N:
if (x[st_idx-K+1+i] < 0 and x[st_idx+i] <= 0):
dist = abs(x[st_idx-K+1+i])
elif (x[st_idx-K+1+i] >= 0 and x[st_idx+i] > 0):
dist = abs(x[st_idx+i])
else:
if abs(x[st_idx-K+1+i]) > abs(x[st_idx+i]):
dist = abs(x[st_idx-K+1+i]) + abs(x[st_idx+i]) * 2
else:
dist = abs(x[st_idx-K+1+i]) * 2 + abs(x[st_idx+i])
elif N < st_idx+1+i:
break
ans = min(ans,dist)
print(ans)
if __name__ == "__main__":
main() | def main():
N, K = (int(i)for i in input().split())
x = [int(i) for i in input().split()]
ans = 3 * (10**8)
for i in range(N-K+1):
dist = min(abs(x[i]),abs(x[i+K-1])) + abs(x[i+K-1] - x[i])
ans = min(ans,dist)
print(ans)
if __name__ == "__main__":
main() | p03274 |
from itertools import combinations
n, k = list(map(int, input().split()))
x = [int(i) for i in input().split()]
c = combinations(x, k)
# print(list(c))
ans = 10 ** 10
for g in c:
a = max(0, max(g))
b = min(0, min(g))
# print(a, b)
if (a * b) < 0:
tmp = min(2 * abs(a) + abs(b), 2 * abs(b) + abs(a))
else:
tmp = abs(a) + abs(b)
ans = min(ans, tmp)
print(ans)
| n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
# c = combinations(x, k)
c = []
for i in range(n - k + 1):
l = x[i]
r = x[i + k - 1]
c.append([l, r])
# print(list(c))
ans = 10 ** 10
for l, r in c:
tmp = min(abs(l) + abs(r - l), abs(r) + abs(r - l))
ans = min(ans, tmp)
# for g in c:
# a = max(0, max(g))
# b = min(0, min(g))
# # print(a, b)
# if (a * b) < 0:
# tmp = min(2 * abs(a) + abs(b), 2 * abs(b) + abs(a))
# else:
# tmp = abs(a) + abs(b)
# ans = min(ans, tmp)
print(ans)
| p03274 |
N,K = list(map(int,input().split()))
X_all = list(map(int,input().split()))
m = float("inf")
for i in range(N-K+1):
X = X_all[i:i+K]
if X[0] > 0:
d = X[-1]
elif X[-1] < 0:
d = -X[0]
else:
d = X[-1]-X[0]+min(-X[0],X[-1])
m = min(m,d)
print(m) | N,K = list(map(int,input().split()))
X = list(map(int,input().split()))
m = 2*(abs(X[-1])+abs(X[0]))
for i in range(N-K+1):
if X[i] > 0:
d = X[i+K-1]
elif X[i+K-1] < 0:
d = -X[i]
else:
d = X[i+K-1]-X[i]+min(-X[i],X[i+K-1])
m = min(m,d)
print(m) | p03274 |
import bisect
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
if 0 in X:
K=K-1
ans=[]
Right=[]
Left=[]
for x in X:
if x>0:
Right.append(x)
else:
Left=[abs(x)]+Left
Right=[0]+Right
Left=[0]+Left
for i in range(K+1):
if i<=len(Right)-1 and K-i<=len(Left)-1:
ans.append(min(Right[i],Left[K-i])*2+max(Right[i],Left[K-i]))
if K==0:
ans.append(0)
print((min(ans))) | N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
ans=[]
for i in range(N-K+1):
xl=X[i]
xr=X[i+K-1]
ans.append(min(abs(xl)+abs(xr-xl),abs(xr)+abs(xl-xr)))
print((min(ans))) | p03274 |
import sys
input = sys.stdin.readline
def func(a):
global alist
cnt = 1
for i in range(len(alist)):
if abs(alist[i][0]) > abs(int(a)):
alist[i][1] += 1
else:cnt += 1
alist.append([int(a),cnt])
return int(a)
alist = []
n,k = list(map(int,input().split()))
x = list(map(func,input().split()))#sort済み
anslist = []
for i in range(len(alist)):
if alist[i][1] <= k:
anslist.append(alist[i][0])
anslist.sort()
#print(alist)
#print(anslist)
if anslist[0] >= 0 and anslist[-1] >= 0:
print((anslist[-1]))
elif anslist[0] <= 0 and anslist[-1] <= 0:
print((-anslist[0]))
else:
if anslist[-1] > -anslist[0]:
print((-2*anslist[0] + anslist[-1]))
else:
print((2*anslist[-1] - anslist[0]))
| n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = float('inf')
for i in range(n-k+1):
left = i
right = i+k-1
ans = min(ans, min(abs(x[left])+abs(x[right]-x[left]),abs(x[right])+abs(x[left]-x[right])))
print(ans)
| p03274 |
import sys
input = sys.stdin.readline
def readstr():
return input().strip()
def readint():
return int(eval(input()))
def readnums():
return list(map(int, input().split()))
def readstrs():
return input().split()
def main():
N, K = readnums()
x = list(readnums())
ans = 0
for i in range(K, N + 1):
l = x[i - K:i]
if l[0] > 0:
val = abs(l[-1])
elif l[-1] < 0:
val = abs(l[0])
else:
val = abs(l[0]) + abs(l[-1])
val += min(abs(l[0]), abs(l[-1]))
if not ans:
ans = val
else:
ans = min(ans, val)
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def readstr():
return input().strip()
def readint():
return int(eval(input()))
def readnums():
return list(map(int, input().split()))
def readstrs():
return input().split()
def main():
N, K = readnums()
x = list(readnums())
ans = 0
for i in range(K - 1, N):
ls = i - K + 1
le = i
if x[ls] > 0:
val = abs(x[le])
elif x[le] < 0:
val = abs(x[ls])
else:
val = abs(x[ls]) + abs(x[le])
val += min(abs(x[ls]), abs(x[le]))
if not ans:
ans = val
else:
ans = min(ans, val)
print(ans)
if __name__ == "__main__":
main()
| p03274 |
import itertools
import collections
n,k=list(map(int,input().split()))
candle=list(map(int,input().split()))
com=list(itertools.product(["1","0"], repeat=n))
ans=200000000
for i in range(2**n):
count=collections.Counter(com[i])
if count["1"]==k:
comtemp="".join(com[i])
start=candle[comtemp.find("1")]
end=candle[comtemp.rfind("1")]
temp=0
if start>=0:
temp=abs(end)
if temp<ans:
ans=temp
if end<=0:
temp=abs(start)
if temp<ans:
ans=temp
else:
temp=min(abs(start), end)*2+max(abs(start), end)
if temp<ans:
ans=temp
print(ans) | n,k=list(map(int,input().split()))
candle=list(map(int,input().split()))
ans=2000000000
for i in range(n-k+1):
if candle[i]<0 and candle[i+k-1]>0:
temp=min(abs(candle[i]), candle[i+k-1])*2+max(abs(candle[i]), candle[i+k-1])
elif candle[i+k-1]<=0:
temp=abs(candle[i])
elif candle[i]>=0:
temp=candle[i+k-1]
ans=min(temp, ans)
print(ans) | p03274 |
N, K = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = pow(10, 10)
for i in range(N-K+1):
temp_l = abs(x[i]) + abs(x[i]-x[i+K-1])
temp_r = abs(x[i+K-1]) + abs(x[i]-x[i+K-1])
ans = min(ans, temp_l, temp_r)
print(ans)
| N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = 10 ** 9
for i in range(len(a) - K + 1):
l = a[i]
r = a[i+K-1]
ans = min(ans, abs(l) + abs(r - l), abs(r) + abs(l - r))
print(ans) | p03274 |
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float('inf')
for i in range(n-k+1):
l, r = X[i:i+k][0], X[i:i+k][-1]
if r < 0:
ans = min(abs(l), ans)
elif 0 < l:
ans = min(abs(r), ans)
else:
ans = min(min(abs(l), abs(r))*2+max(abs(l), abs(r)), 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, r = X[i], X[i+k-1]
if r <= 0:
ans = min(abs(l), ans)
elif 0 <= l:
ans = min(abs(r), ans)
else:
dist = min(abs(l), abs(r))*2+max(abs(l), abs(r))
ans = min(dist, ans)
print(ans) | p03274 |
N,K=list(map(int,input().split()))
*X,=list(map(int,input().split()))
A=[]
B=[]
for x in X:
if x>=0:
A.append(x)
else:
B.append(abs(x))
B.sort()
i=min(K,len(A))
j=K-i
ans=[]
while i>=0 and j<=len(B):
if i==0:
ans.append(B[j-1])
elif j==0:
ans.append(A[i-1])
else:
a,b=A[i-1],B[j-1]
ans.append(a+b+min(a,b))
i-=1
j+=1
print((min(ans))) | N,K=list(map(int,input().split()))
*X,=list(map(int,input().split()))
i=0
ans=[]
while i+K-1<N:
a,b=X[i],X[i+K-1]
if b<0:
ans.append(abs(a))
elif a>0:
ans.append(b)
else:
a=abs(a)
ans.append(a+b+min(a,b))
i+=1
print((min(ans))) | p03274 |
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = float('inf')
for left in range(N - K + 1) :
if X[left] < 0 and X[left + K - 1] >= 0 :
l = -X[left] * 2 + X[left + K - 1]
r = -X[left] + X[left + K - 1] * 2
ans = min(ans, l, r)
elif X[left + K - 1] < 0 :
ans = min(ans, -X[left])
else :
ans = min(ans, X[left + K - 1])
print(ans) | 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)
| p03274 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.