input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,q,*t=list(map(int,open(0).read().split()))
for v,w in zip(t[::2],t[1::2]):
if~-n:
while v!=w:
if v>w:v,w=w,v
w=(w+n-2)//n
print(v) | n,q,*t=list(map(int,open(0).read().split()))
for v,w in zip(t[::2],t[1::2]):
while n>1and v!=w:
if v>w:v,w=w,v
w=(w+n-2)//n
print(v) | p03506 |
n, a, b = list(map(int, input().split()))
pre_h = [int(eval(input())) for _ in range(n)]
minimum = (min(pre_h) - 1) // a + 1
h = [0] * n
while True:
for i in range(n):
if pre_h[i] - b * minimum > 0:
h[i] = pre_h[i] - b * minimum
else:
h[i] = 0
if sum([(i - 1) // (a - b) + 1 for i in h]) <= minimum:
break
#print(h)
minimum += 1
print(minimum) | n, a, b = list(map(int, input().split()))
pre_h = [int(eval(input())) for _ in range(n)]
def check(cnt):
h = [0] * n
for i in range(n):
if pre_h[i] - b * cnt > 0:
h[i] = pre_h[i] - b * cnt
else:
h[i] = 0
if sum([(i - 1) // (a - b) + 1 for i in h]) <= cnt:
return True
else:
return False
minimum = 1
maximum = (max(pre_h) - 1) // b + 1
while maximum - minimum > 1:
if check(minimum + (maximum - minimum) // 2):
maximum = minimum + (maximum - minimum) // 2
else:
minimum = minimum + (maximum - minimum) // 2
print(maximum) | p03702 |
def inpl(): return [int(i) for i in input().split()]
N,A,B = inpl()
C = A-B
h = [int(eval(input())) for _ in range(N)]
ans = -(-sum(h)//((N-1)*B+A))
while True:
hprime = [h[i]-ans*B for i in range(N) if h[i]-ans*B >0]
hans = ans
for j in hprime:
hans -= -(-j//C)
if hans >= 0:
break
ans += 1
print(ans) | def inpl(): return [int(i) for i in input().split()]
N,A,B = inpl()
C = A-B
h = [int(eval(input())) for _ in range(N)]
lo = -(-sum(h)//((N-1)*B+A)) -1
hi = sum([-(-i//A) for i in h])
while hi - lo > 1:
me = (hi+lo)//2
hprime = [h[i]-me*B for i in range(N) if h[i]-me*B >0]
hans = 0
for j in hprime:
hans += -(-j//C)
if hans <= me:
hi = me
else:
lo = me
print(hi) | p03702 |
import bisect
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def ceil(x):
return int((-x)//1*(-1))
N, A, B = list(map(int, input().split()))
hp = [int(eval(input())) for _ in range(N)]
diff = A-B
def solve1():
HP = sorted(hp, reverse=True)
cnt = 0
while HP:
HP = list([x-B for x in HP])
HP[0] -= A-B
HP = list([x for x in HP if x > 0])
HP = sorted(HP, reverse=True)
cnt += 1
print(HP)
print(cnt)
def check(x, HP):
cnt = 0
for i in range(N):
if HP[i]-B*x <= 0:
break
else:
cnt += ceil((HP[i]-B*x)/diff)
#print("x->", x)
# print(cnt)
#print(cnt <= x)
return cnt <= x
def solve2():
HP = sorted(hp, reverse=True)
mi = HP[0]//A
ma = ceil(HP[0]/B)
#print("mi,ma->", mi, ma)
while mi <= ma:
mid = (mi+ma)//2
if check(mid, HP):
ma = mid-1
else:
mi = mid+1
print(mi)
solve2()
| # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def ceil(x):
return int((-x)//1*(-1))
N, A, B = list(map(int, input().split()))
hp = [int(eval(input())) for _ in range(N)]
diff = A-B
def check(x, HP):
cnt = 0
for i in range(N):
if HP[i]-B*x <= 0:
break
else:
cnt += ceil((HP[i]-B*x)/diff)
return cnt <= x
def solve2():
HP = sorted(hp, reverse=True)
mi = HP[0]//A
ma = ceil(HP[0]/B)
while mi <= ma:
mid = (mi+ma)//2
if check(mid, HP):
ma = mid-1
else:
mi = mid+1
print(mi)
solve2()
| p03702 |
import math
N, A, B = list(map(int, input().split()))
h = []
min_h = 10 ** 10
max_h = 0
for _ in range(N):
hi = int(eval(input()))
if hi < min_h:
min_h = hi
if hi > max_h:
max_h = hi
h.append(hi)
min_K = math.ceil(min_h / A)
max_K = math.ceil(max_h / B)
K = min_K
while(min_K != max_K):
x = [math.ceil((n - K * B) / (A - B)) for n in h]
sum_x = sum([xi for xi in x if xi > 0])
if sum_x <= K:
max_K = K
K = math.floor((min_K + K) / 2)
else:
min_K = K + 1
K = math.floor((K + max_K) / 2) + 1
print(min_K) | import math
N, A, B = list(map(int, input().split()))
h = []
min_h = 10 ** 10
max_h = 0
for _ in range(N):
hi = int(eval(input()))
if hi < min_h:
min_h = hi
if hi > max_h:
max_h = hi
h.append(hi)
min_K = math.ceil(sum(h) / (A - B + B * N)) - 1
max_K = math.ceil(max(h) / A) * N
min_K = math.ceil(min_h / A)
max_K = math.ceil(max_h / B)
K = min_K
while(min_K != max_K):
x = [math.ceil((n - K * B) / (A - B)) for n in h]
sum_x = sum([xi for xi in x if xi > 0])
if sum_x <= K:
max_K = K
K = math.floor((min_K + K) / 2)
else:
min_K = K + 1
K = math.floor((K + max_K) / 2) + 1
print(K) | p03702 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# from numpy import array, sum
N, A, B = list(map(int, input().split()))
h_li = []
for i in range(N):
h_li.append(int(eval(input())))
def all_beatable_check(k):
# All enemy get B damage every time
h_damaged = [h - B*k for h in h_li]
# print(h_damaged)
# A-B damage will be additionally given to enemies s.t. HP > 0
ex_dmg = A - B
h_ex_needed = [(h+ex_dmg-1) // ex_dmg if h > 0 else 0 for h in h_damaged]
# print(h_ex_needed)
# how many A-B damage is needed to beat all enemies
hits_needed = sum(h_ex_needed)
if hits_needed > k:
return False
else:
return True
MIN_K = 0 # impossible
MAX_K = max(h_li) # possible
while MAX_K - MIN_K > 1:
# print(f"{MIN_K}-{MAX_K} {MIN_K + (MAX_K - MIN_K) // 2}")
k = MIN_K + (MAX_K - MIN_K) // 2
res = all_beatable_check(k)
if res is True:
MAX_K = k
elif res is False:
MIN_K = k
print(MAX_K) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# from numpy import array, sum
N, A, B = list(map(int, input().split()))
h_li = []
for i in range(N):
h_li.append(int(eval(input())))
def all_beatable_check(k):
# All enemy get B damage every time
h_damaged = [h - B*k for h in h_li]
# print(h_damaged)
# A-B damage will be additionally given to enemies s.t. HP > 0
ex_dmg = A - B
h_ex_needed = [(h+ex_dmg-1) // ex_dmg if h > 0 else 0 for h in h_damaged]
# print(h_ex_needed)
# how many A-B damage is needed to beat all enemies
hits_needed = sum(h_ex_needed)
if hits_needed > k:
return False
else:
return True
MIN_K = 0 # impossible
MAX_K = max(h_li) # possible
while MAX_K - MIN_K > 1:
# print(f"{MIN_K}-{MAX_K} {MIN_K + (MAX_K - MIN_K) // 2}")
k = (MIN_K + MAX_K) // 2
res = all_beatable_check(k)
if res is True:
MAX_K = k
elif res is False:
MIN_K = k
print(MAX_K) | p03702 |
import math
n, a, b = list(map(int, input().split()))
hs = list(map(int, (eval(input()) for _ in range(n))))
m = sum(hs) // (a + (n-1)*b) - 10
M = sum(math.ceil(h/a) for h in hs)
def killable(p, hs, a, b):
x = sum(max(0, math.ceil((h-p*b) / (a-b))) for h in hs)
return x <= p
while(m+1 < M):
c = (m+M) // 2
if killable(c, hs, a, b):
M = c
else:
m = c
print(M) | import math
n, a, b = list(map(int, input().split()))
hs = list(map(int, (eval(input()) for _ in range(n))))
m = sum(hs) // (a + (n-1)*b) - 1
#M = sum(math.ceil(h/a) for h in hs)
M = max(hs) // b + 1
def killable(p, hs, a, b):
x = sum(max(0, math.ceil((h-p*b) / (a-b))) for h in hs)
return x <= p
while(m+1 < M):
c = (m+M) // 2
if killable(c, hs, a, b):
M = c
else:
m = c
print(M) | p03702 |
# -*- coding: utf-8 -*-
from bisect import bisect
def inpl(): return tuple(map(int, input().split()))
N, A, B = inpl()
D = A-B
H = []
res = 0
for _ in range(N):
H.append(int(eval(input())))
x = sum(H) // (A+B*(N-1))
H = sorted(H)
while len(H):
nH = [h - B*x for h in H]
i = bisect(nH, 0)
nH = nH[i:]
H = H[i:]
if sum([h//D + (h%D>0) for h in nH]) <= x:
print(x)
break
else:
x = max(x+1, sum(H) // (A+B*(N-1))) | # -*- coding: utf-8 -*-
def inpl(): return tuple(map(int, input().split()))
N, A, B = inpl()
D = A-B
H = []
res = 0
for _ in range(N):
H.append(int(eval(input())))
H = sorted(H)
l = sum(H) // (A+B*(N-1))
r = sum([h//A + (h%A>0) for h in H])
def judge(m):
nH = [h - B*m for h in H]
if sum([h//D + (h%D>0) for h in nH if h > 0]) <= m:
return True
else:
return False
while r-l > 1:
mid = (l+r)//2
if judge(mid):
r = mid
else:
l = mid
if judge(l):
print(l)
else:
print(r) | p03702 |
n, a, b = list(map(int, input().split()))
h = [int(eval(input())) for i in range(n)]
h.sort()
def check(k):
top = 0
tmp = h[::]
for i in range(n):
amari = tmp[i] - b*k
if amari > 0:
top += -(-amari//(a-b))
return top <= k
# 二分探索
left = 0
right = -(-1*sum(h)//b)
while(right-left>1):
next_ind = (left + right)//2
if check(next_ind):
right = next_ind
else:
left = next_ind
print(right) | n, a, b = list(map(int, input().split()))
h = [int(eval(input())) for i in range(n)]
def check(k):
cnt = 0
for i in h:
hp = i - k*b
if hp > 0:
cnt += -(-hp//(a-b))
return cnt <= k
left = 0
right = 10**10
while right - left>1:
mid = (right + left)//2
if check(mid):
right = mid
else:
left = mid
print(right)
| p03702 |
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
S = input()
if S == '0':
break
m = {}
for i in range(11):
m[i] = []
m[0].append(11)
diff = 0
even = True
S = reversed(S)
for c in S:
num = int(c)
if even:
diff += num
else:
diff -= num
diff %= 11
m[diff].append(num)
even = (not even)
ans = 0
#print m
for i in range(11):
lst = m[i]
for i in range(len(lst)):
if lst[i] != 0:
ans += i
print(ans)
| #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
S = input()
if S == '0':
break
m = [0 for i in range(11)]
m[0] = 1
diff = 0
even = True
S = reversed(S)
ans = 0
for c in S:
num = int(c)
if even:
diff += num
else:
diff -= num
diff %= 11
if num != 0:
ans += m[diff]
m[diff] += 1
even = (not even)
print(ans)
| p01300 |
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
S = input()
if S == '0':
break
m = [0 for i in range(11)]
m[0] = 1
diff = 0
even = True
S = reversed(S)
ans = 0
for c in S:
num = int(c)
if even:
diff += num
else:
diff -= num
diff %= 11
if num != 0:
ans += m[diff]
m[diff] += 1
even = (not even)
print(ans)
| while True:
S = input()
if S == '0':
break
m = [0 for i in range(11)]
m[0] = 1
diff = 0
even = True
S = reversed(S)
ans = 0
for c in S:
num = int(c)
if even:
diff += num
else:
diff -= num
diff %= 11
if num != 0:
ans += m[diff]
m[diff] += 1
even = (not even)
print(ans)
| p01300 |
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
S = input()
if S == '0':
break
m = [1] + [0 for i in range(10)]
diff = 0
even = 1
S = reversed(S)
ans = 0
for c in S:
num = int(c)
diff += num * even
diff %= 11
if num != 0:
ans += m[diff]
m[diff] += 1
even *= -1
print(ans)
| #!/usr/bin/env python
from collections import deque
import itertools as it
import sys
sys.setrecursionlimit(1000000)
while True:
S = input()
if S == '0':
break
m = [1] + [0 for i in range(10)]
diff = ans = 0
even = 1
S = reversed(S)
for c in S:
num = int(c)
diff = (diff + num * even) % 11
if num != 0:
ans += m[diff]
m[diff] += 1
even *= -1
print(ans)
| p01300 |
while True:
S=input()
if S=='0':break
m=[1]+[0 for i in range(10)]
d=A=0
e=1
S=reversed(S)
for c in S:
d=(d+int(c)*e)%11
if int(c)!=0:A+=m[d]
m[d]+=1
e*=-1
print(A)
| while True:
S = input()[::-1]
if S == '0' : break
m = [1] + [0] * 10
diff = ans = 0
even = 1
for c in S:
num = int(c)
diff = (diff + num * even) % 11
if num : ans += m[diff]
m[diff] += 1
even *= -1
print(ans)
| p01300 |
import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
As = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
A, B = list(map(int, input().split()))
adjL[A-1].append(B-1)
adjL[B-1].append(A-1)
def dfsTree(vNow):
useds[vNow] = True
for v2 in adjL[vNow]:
if not useds[v2]:
chlds[vNow].append(v2)
dfsTree(v2)
vRoot = 0
chlds = [[] for v in range(N)]
useds = [False] * N
dfsTree(vRoot)
def dfs(vNow):
if not chlds[vNow]:
return As[vNow]
cs = []
for chld in chlds[vNow]:
c = dfs(chld)
if c == -1:
return -1
cs.append(c)
sumC = sum(cs)
T = 2*As[vNow] - sumC
L = sumC - As[vNow]
if T < 0 or L < 0:
return -1
if min(sumC-max(cs), sumC//2) >= L:
return T
else:
return -1
ans = dfs(vRoot)
isLeaf = len(chlds[vRoot]) == 1
if (isLeaf and ans == As[vRoot]) or (not isLeaf and ans == 0):
print('YES')
else:
print('NO')
| import sys
sys.setrecursionlimit(10**9)
N = int(eval(input()))
As = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
A, B = list(map(int, input().split()))
adjL[A-1].append(B-1)
adjL[B-1].append(A-1)
def dfsTree(vNow):
useds[vNow] = True
for v2 in adjL[vNow]:
if not useds[v2]:
chlds[vNow].append(v2)
dfsTree(v2)
vRoot = 0
chlds = [[] for v in range(N)]
useds = [False] * N
dfsTree(vRoot)
def dfs(vNow):
if not chlds[vNow]:
return As[vNow]
cs = []
for chld in chlds[vNow]:
c = dfs(chld)
if c == -1:
return -1
cs.append(c)
sumC = sum(cs)
T = 2*As[vNow] - sumC
if T < 0:
return -1
cs.append(T)
sumC += T
if max(cs) <= sumC/2:
return T
else:
return -1
ans = dfs(vRoot)
isLeaf = len(chlds[vRoot]) == 1
if (isLeaf and ans == As[vRoot]) or (not isLeaf and ans == 0):
print('YES')
else:
print('NO')
| p03809 |
while True:
n = eval(input())
if n == 0: break
P = set(tuple(map(int, input().split())) for i in range(n))
ans = 0
for xi, yi in P:
for xj, yj in P:
q = (xj - yj + yi, yj + xj - xi)
r = (xi - yj + yi, yi + xj - xi)
if q in P and r in P:
ans = max(ans, pow(xi - xj, 2) + pow(yi - yj, 2))
print(ans) | while True:
n = eval(input())
if n == 0: break
P = set(tuple(map(int, input().split())) for i in range(n))
ans = 0
for xi, yi in P:
for xj, yj in P:
q = (xj - yj + yi, yj + xj - xi)
r = (xi - yj + yi, yi + xj - xi)
if q in P and r in P:
ans = max(ans, (xi - xj) ** 2 + (yi - yj) ** 2)
print(ans) | p00441 |
while True:
n = eval(input())
if n == 0: break
P = set(tuple(map(int, input().split())) for i in range(n))
ans = 0
for xi, yi in P:
for xj, yj in P:
q = (xj - yj + yi, yj + xj - xi)
r = (xi - yj + yi, yi + xj - xi)
if q in P and r in P:
ans = max(ans, (xi - xj) ** 2 + (yi - yj) ** 2)
print(ans) | while True:
n = eval(input())
if n == 0: break
P = [(list(map(int, input().split()))) for i in range(n)]
S = set(map(tuple, P))
ans = 0
for i in range(n - 1):
xi, yi = P[i]
for j in range(i + 1, n):
xj, yj = P[j]
q = (xj - yj + yi, yj + xj - xi)
r = (xi - yj + yi, yi + xj - xi)
if q in S and r in S:
ans = max(ans, (xi - xj) ** 2 + (yi - yj) ** 2)
print(ans) | p00441 |
def main():
#points = [[False for i in range(5001)] for j in range(5001)]
while True:
n = int(eval(input()))
if not n:
break
ps = []
dic = {}
for i in range(n):
x, y = list(map(int,input().split()))
dic[(x, y)] = 1;
#points[x][y] = True
ps.append((x,y))
ans = 0
for i in range(n):
for j in range(n):
p1 = ps[i]
p2 = ps[j]
vx = p2[0] - p1[0]
vy = p2[1] - p1[1]
#if 0 <= p1[0] + vy <= 5000 and 0 <= p1[1] - vx <= 5000 and 0 <= p2[0] + vy <= 5000 and 0 <= p2[1] - vx <= 5000:
# if points[p1[0] + vy][p1[1] - vx] and points[p2[0] + vy][p2[1] - vx]:
if (p1[0] + vy, p1[1] - vx) in dic and (p2[0] + vy, p2[1] - vx) in dic:
ans = max(ans, vx ** 2 + vy ** 2)
#for p in ps:
# points[p[0]][p[1]] = False
print(ans)
main()
| def main():
while True:
n = int(eval(input()))
if not n:
break
ps = []
dic = {}
for i in range(n):
x, y = list(map(int,input().split()))
dic[(x, y)] = 1;
ps.append((x,y))
ans = 0
for i in range(n):
for j in range(n):
p1 = ps[i]
p2 = ps[j]
p1x = p1[0]
p1y = p1[1]
p2x = p2[0]
p2y = p2[1]
vx = p2x - p1x
vy = p2y - p1y
if (p1x + vy, p1y - vx) in dic and (p2x + vy, p2y - vx) in dic:
ans = max(ans, vx ** 2 + vy ** 2)
print(ans)
main()
| p00441 |
def main():
while True:
n = int(eval(input()))
if not n:
break
ps = []
dic = {}
for i in range(n):
x, y = list(map(int,input().split()))
dic[(x, y)] = 1;
ps.append((x,y))
ans = 0
for i in range(n):
for j in range(n):
p1 = ps[i]
p2 = ps[j]
p1x = p1[0]
p1y = p1[1]
p2x = p2[0]
p2y = p2[1]
vx = p2x - p1x
vy = p2y - p1y
if (p1x + vy, p1y - vx) in dic and (p2x + vy, p2y - vx) in dic:
ans = max(ans, vx ** 2 + vy ** 2)
print(ans)
main()
| def main():
while True:
n = int(eval(input()))
if not n:
break
ps = [list(map(int,input().split())) for i in range(n)]
dic = set()
for t in ps:
dic.add((t[0],t[1]))
ans = 0
for i in range(n):
for j in range(n):
p1 = ps[i]
p2 = ps[j]
p1x = p1[0]
p1y = p1[1]
p2x = p2[0]
p2y = p2[1]
vx = p2x - p1x
vy = p2y - p1y
if (p1x + vy, p1y - vx) in dic and (p2x + vy, p2y - vx) in dic:
ans = max(ans, vx ** 2 + vy ** 2)
print(ans)
main()
| p00441 |
import itertools
while 1:
n = eval(input())
if n == 0: break
xy = sorted([list(map(int,input().split())) for i in range(n)])
dxy = [[xy1[0]-xy2[0],xy1[1]-xy2[1]] for xy1,xy2 in itertools.combinations(xy,2)]
for i in range(len(dxy)-1,-1,):
if dxy.count(dxy[i]) < 2: del dxy[i]
dxy = sorted(dxy, key = lambda d:d[0]**2 + d[1]**2, reverse = True)
for dx,dy in dxy:
if dxy.count([dy,-dx]) > 1 or dxy.count([-dy,-dx]) > 1:
print(dx**2 + dy**2)
break
else:
print(0) | p = 100
while 1:
n = eval(input())
if n == 0: break
xy = sorted([list(map(int,input().split())) for i in range(n)])
S = set(map(tuple,xy))
ans = 0
for i in range(n):
x1,y1 = xy[i]
xy = xy[:i] + sorted(xy[i:], key = lambda XY:(XY[0]-x1)**2 + (XY[1]-y1)**2)
cur = 0
for j in range(n-1,i,-1):
x2,y2 = xy[j]
a = (x2-y2+y1,y2+x2-x1)
b = (x1-y2+y1,y1+x2-x1)
if a in S and b in S:
cur = (x1-x2)**2 + (y1-y2)**2
break
ans = max(ans,cur)
print(ans) | p00441 |
p = 100
while 1:
n = eval(input())
if n == 0: break
xy = sorted([list(map(int,input().split())) for i in range(n)])
S = set(map(tuple,xy))
ans = 0
for i in range(n):
x1,y1 = xy[i]
xy = xy[:i] + sorted(xy[i:], key = lambda XY:(XY[0]-x1)**2 + (XY[1]-y1)**2)
cur = 0
for j in range(n-1,i,-1):
x2,y2 = xy[j]
a = (x2-y2+y1,y2+x2-x1)
b = (x1-y2+y1,y1+x2-x1)
if a in S and b in S:
cur = (x1-x2)**2 + (y1-y2)**2
break
ans = max(ans,cur)
print(ans) | while 1:
n = eval(input())
if n == 0: break
xy = [list(map(int,input().split())) for i in range(n)]
S = set(map(tuple,xy))
ans = 0
for i in range(n):
x1,y1 = xy[i]
for j in range(n-1,i,-1):
x2,y2 = xy[j]
a = (x2-y2+y1,y2+x2-x1)
b = (x1-y2+y1,y1+x2-x1)
if a in S and b in S:
ans = max(ans,(x1-x2)**2 + (y1-y2)**2)
print(ans) | p00441 |
def dot(c1, c2):
return c1.real * c2.real + c1.imag * c2.imag
def cross(c1, c2):
return c1.real * c2.imag - c1.imag * c2.real
def string_to_complex(s):
x, y = list(map(int, s.split()))
return x + y * 1j
def contains(polygon, point):
up = False
down = False
start_point = polygon[0]
for p in polygon[::-1]:
if start_point.imag > p.imag:
up = True
break
elif start_point.imag < p.imag:
down = True
break
flag = False
for v1, v2 in zip(polygon[0:], polygon[1:]):
a = v1 - point
b = v2 - point
if cross(a, b) == 0 and dot(a, b) <= 0:
return 1
if a.imag < b.imag:
if a.imag < 0 or (a.imag == 0 and up):
if b.imag > 0 and cross(a, b) > 0:
flag = not flag
up = True
down = False
elif a.imag > b.imag:
if a.imag > 0 or (a.imag == 0 and down):
if b.imag < 0 and cross(a, b) < 0:
flag = not flag
up = False
down = True
if flag:
return 2
else:
return 0
import sys
file_input = sys.stdin
n = int(file_input.readline())
polygon = [string_to_complex(file_input.readline()) for i in range(n)]
polygon.append(polygon[0])
q = int(file_input.readline())
for line in file_input:
t = string_to_complex(line)
print((contains(polygon, t))) | def dot(c1, c2):
return c1.real * c2.real + c1.imag * c2.imag
def cross(c1, c2):
return c1.real * c2.imag - c1.imag * c2.real
def string_to_complex(s):
x, y = list(map(int, s.split()))
return x + y * 1j
def contains(polygon, point):
flag = False
for v1, v2 in zip(polygon[0:], polygon[1:]):
a = v1 - point
b = v2 - point
if a.imag > b.imag:
a, b = b, a
cross_ab = cross(a, b)
if a.imag <= 0 and b.imag > 0 and cross_ab > 0:
flag = not flag
if cross_ab == 0 and dot(a, b) <= 0:
return 1
if flag:
return 2
else:
return 0
import sys
file_input = sys.stdin
n = int(file_input.readline())
polygon = [string_to_complex(file_input.readline()) for i in range(n)]
polygon.append(polygon[0])
q = int(file_input.readline())
for line in file_input:
t = string_to_complex(line)
print((contains(polygon, t))) | p02299 |
def dot(c1, c2):
return c1.real * c2.real + c1.imag * c2.imag
def cross(c1, c2):
return c1.real * c2.imag - c1.imag * c2.real
def string_to_complex(s):
x, y = list(map(int, s.split()))
return x + y * 1j
def contains(polygon, point):
flag = False
for v1, v2 in zip(polygon[0:], polygon[1:]):
a = v1 - point
b = v2 - point
if a.imag > b.imag:
a, b = b, a
cross_ab = cross(a, b)
if a.imag <= 0 and b.imag > 0 and cross_ab > 0:
flag = not flag
if cross_ab == 0 and dot(a, b) <= 0:
return 1
if flag:
return 2
else:
return 0
import sys
file_input = sys.stdin
n = int(file_input.readline())
polygon = [string_to_complex(file_input.readline()) for i in range(n)]
polygon.append(polygon[0])
q = int(file_input.readline())
for line in file_input:
t = string_to_complex(line)
print((contains(polygon, t))) | def dot(c1, c2):
return c1.real * c2.real + c1.imag * c2.imag
def cross(c1, c2):
return c1.real * c2.imag - c1.imag * c2.real
def string_to_complex(s):
x, y = list(map(int, s.split()))
return x + y * 1j
def contains(polygon, point):
flag = False
for v1, v2 in zip(polygon[0:], polygon[1:]):
a = v1 - point
b = v2 - point
if a.imag > b.imag:
a, b = b, a
cross_ab = cross(a, b)
if cross_ab == 0 and dot(a, b) <= 0:
return 1
if a.imag <= 0 and b.imag > 0 and cross_ab > 0:
flag = not flag
if flag:
return 2
else:
return 0
import sys
file_input = sys.stdin
n = int(file_input.readline())
polygon = [string_to_complex(file_input.readline()) for i in range(n)]
polygon.append(polygon[0])
q = int(file_input.readline())
for line in file_input:
t = string_to_complex(line)
print((contains(polygon, t))) | p02299 |
from math import atan2
n = eval(input())
p = [list(map(int, input().split())) for i in range(n)]
for t in range(eval(input())):
x, y = list(map(int, input().split()))
inline = 0
theta = 0.
for i in range(n):
x0 = p[i-1][0] - x
y0 = p[i-1][1] - y
x1 = p[i][0] - x
y1 = p[i][1] - y
if x0*y1 == y0*x1 and x0*x1+y0*y1 <= 0:
inline = 1
break
theta += atan2(x0*y1-y0*x1, x0*x1+y0*y1)
if inline:
print(1)
elif theta > 1:
print(2)
else:
print(0) | def inside_polygon(p0, qs):
cnt = 0
L = len(qs)
x, y = p0
for i in range(L):
x0, y0 = qs[i-1]; x1, y1 = qs[i]
x0 -= x; y0 -= y
x1 -= x; y1 -= y
cv = x0*x1 + y0*y1
sv = x0*y1 - x1*y0
if sv == 0 and cv <= 0:
return 1
if not y0 < y1:
x0, x1 = x1, x0
y0, y1 = y1, y0
if y0 <= 0 < y1 and x0*(y1 - y0) > y0*(x1 - x0):
cnt += 1
return 2 if cnt % 2 == 1 else 0
def solve():
N = int(eval(input()))
qs = [list(map(int, input().split())) for i in range(N)]
Q = int(eval(input()))
for i in range(Q):
*p0, = list(map(int, input().split()))
print((inside_polygon(p0, qs)))
solve()
| p02299 |
import sys
from operator import itemgetter, attrgetter
from itertools import starmap
import cmath
from math import isinf, sqrt, acos, atan2
readline = sys.stdin.readline
EPS = 1e-9
ONLINE_FRONT = -2
CLOCKWISE = -1
ON_SEGMENT = 0
COUNTER_CLOCKWISE = 1
ONLINE_BACK = 2
class Circle(object):
__slots__ = ('c', 'r')
def __init__(self, c, r):
self.c = c
self.r = r
class Segment(object):
__slots__ = ('fi', 'se')
def __init__(self, fi, se):
self.fi = fi
self.se = se
Line = Segment
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def norm(base):
return abs(base) ** 2
def project(s, p2):
base = s.fi - s.se
r = dot(p2 - s.fi, base) / norm(base)
return s.fi + base * r
def reflect(s, p):
return p + (project(s, p) - p) * 2.0
def ccw(p1, p2, p3):
a = p2 - p1
b = p3 - p1
if cross(a, b) > EPS: return 1
if cross(a, b) < -EPS: return -1
if dot(a, b) < -EPS: return 2
if norm(a) < norm(b): return -2
return 0
def intersect4(p1, p2, p3, p4):
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 and
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0)
def intersect2(s1, s2):
return intersect4(s1.fi, s1.se, s2.fi, s2.se)
def getDistance(a, b): return abs(a - b)
def getDistanceLP(l, p):
return abs(cross(l.se - l.fi, p - l.fi) / abs(l.se - l.fi))
def getDistanceSP(s, p):
if dot(s.se - s.fi, p - s.fi) < 0.0: return abs(p - s.fi)
if dot(s.fi - s.se, p - s.se) < 0.0: return abs(p - s.se)
return getDistanceLP(s, p)
def getDistances(s1, s2):
if intersect2(s1, s2): return 0.0
return min(getDistanceSP(s1, s2.fi), getDistanceSP(s1, s2.se),
getDistanceSP(s2, s1.fi), getDistanceSP(s2, s1.se))
def getCrossPoint(s1, s2):
base = s2.se - s2.fi
d1 = abs(cross(base, s1.fi - s2.fi))
d2 = abs(cross(base, s1.se - s2.fi))
t = d1 / (d1 + d2)
return s1.fi + (s1.se - s1.fi) * t
def getCrossPointsCL(c, l):
pr = project(l, c.c)
e = (l.se - l.fi) / abs(l.se - l.fi)
base = sqrt(c.r * c.r - norm(pr - c.c))
return Segment(*sorted((pr + e * base, pr - e * base)), key=attrgetter('real', 'imag'))
def getCrossPointsCC(c1, c2):
d = abs(c1.c - c2.c)
a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2.0 * c1.r * d))
t = cmath.phase(c2.c - c1.c)
return Segment(*sorted((c1.c + cmath.rect(c1.r, t + a), c1.c + cmath.rect(c1.r, t - a)), key=attrgetter('real', 'imag')))
def contains(g, p):
n = len(g)
x = False
for i in range(n):
a = g[i] - p
b = g[(i + 1) % n] - p
if abs(cross(a, b)) < EPS and dot(a, b) < EPS: return 1
if a.imag > b.imag: a, b = b, a
if a.imag < EPS and EPS < b.imag and cross(a, b) > EPS: x = not x
return 2 if x else 0
n = int(readline())
pg = tuple(complex(*list(map(int, readline().split()))) for _ in [0] * n)
q = int(readline())
for _ in [0] * q:
print((contains(pg, complex(*list(map(float, readline().split())))))) | import sys
from operator import itemgetter, attrgetter
from itertools import starmap
import cmath
from math import isinf, sqrt, acos, atan2
readline = sys.stdin.readline
EPS = 1e-9
ONLINE_FRONT = -2
CLOCKWISE = -1
ON_SEGMENT = 0
COUNTER_CLOCKWISE = 1
ONLINE_BACK = 2
class Circle(object):
__slots__ = ('c', 'r')
def __init__(self, c, r):
self.c = c
self.r = r
class Segment(object):
__slots__ = ('fi', 'se')
def __init__(self, fi, se):
self.fi = fi
self.se = se
Line = Segment
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def norm(base):
return abs(base) ** 2
def project(s, p2):
base = s.fi - s.se
r = dot(p2 - s.fi, base) / norm(base)
return s.fi + base * r
def reflect(s, p):
return p + (project(s, p) - p) * 2.0
def ccw(p1, p2, p3):
a = p2 - p1
b = p3 - p1
if cross(a, b) > EPS: return 1
if cross(a, b) < -EPS: return -1
if dot(a, b) < -EPS: return 2
if norm(a) < norm(b): return -2
return 0
def intersect4(p1, p2, p3, p4):
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 and
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0)
def intersect2(s1, s2):
return intersect4(s1.fi, s1.se, s2.fi, s2.se)
def getDistance(a, b): return abs(a - b)
def getDistanceLP(l, p):
return abs(cross(l.se - l.fi, p - l.fi) / abs(l.se - l.fi))
def getDistanceSP(s, p):
if dot(s.se - s.fi, p - s.fi) < 0.0: return abs(p - s.fi)
if dot(s.fi - s.se, p - s.se) < 0.0: return abs(p - s.se)
return getDistanceLP(s, p)
def getDistances(s1, s2):
if intersect2(s1, s2): return 0.0
return min(getDistanceSP(s1, s2.fi), getDistanceSP(s1, s2.se),
getDistanceSP(s2, s1.fi), getDistanceSP(s2, s1.se))
def getCrossPoint(s1, s2):
base = s2.se - s2.fi
d1 = abs(cross(base, s1.fi - s2.fi))
d2 = abs(cross(base, s1.se - s2.fi))
t = d1 / (d1 + d2)
return s1.fi + (s1.se - s1.fi) * t
def getCrossPointsCL(c, l):
pr = project(l, c.c)
e = (l.se - l.fi) / abs(l.se - l.fi)
base = sqrt(c.r * c.r - norm(pr - c.c))
return Segment(*sorted((pr + e * base, pr - e * base)), key=attrgetter('real', 'imag'))
def getCrossPointsCC(c1, c2):
d = abs(c1.c - c2.c)
a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2.0 * c1.r * d))
t = cmath.phase(c2.c - c1.c)
return Segment(*sorted((c1.c + cmath.rect(c1.r, t + a), c1.c + cmath.rect(c1.r, t - a)), key=attrgetter('real', 'imag')))
def contains(g, p):
n = len(g)
x = False
for i in range(n):
a = g[i] - p
b = g[(i + 1) % n] - p
if abs(cross(a, b)) < EPS and dot(a, b) < EPS: return 1
if a.imag > b.imag: a, b = b, a
if a.imag < EPS and EPS < b.imag and cross(a, b) > EPS: x = not x
return 2 if x else 0
n = int(readline())
pg = tuple(complex(*list(map(int, readline().split()))) for _ in [0] * n)
q = int(readline())
for _ in [0] * q:
print((contains(pg, complex(*list(map(int, readline().split())))))) | p02299 |
#coding:utf-8
n, k = list(map(int, input().split()))
backList = []
for i in range(n):
backList.append(int(eval(input())))
def capa(p,k):
cnt = 0
pcopy = p
num = 0
for back in backList:
if back > p:
break
if back <= pcopy:
pcopy -= back
cnt += 1
continue
elif back > pcopy:
if num == k-1:
return cnt
pcopy = p - back
cnt += 1
num += 1
return cnt
p_min = 0
p_max = 100000 * 10000
def biSearch(p_min, p_max):
p = p_max - p_min
if p_min == p_max:
return p_min
if p % 2 == 0:
p = int(p/2)
else:
p = int((p+1)/2)
v = capa(p,k)
if v < n:
p_min = p_min + p
else:
p_max = p_min + p
return biSearch(p_min, p_max)
p = biSearch(p_min, p_max)
n_init = n
while n_init <= n:
p -= 1
n = capa(p,k)
print((p+1))
| #coding:utf-8
n, k = list(map(int, input().split()))
backList = []
for i in range(n):
backList.append(int(eval(input())))
def capa(p,k):
cnt = 0
pcopy = p
num = 0
for back in backList:
if back > p:
break
if back <= pcopy:
pcopy -= back
cnt += 1
continue
elif back > pcopy:
if num == k-1:
return cnt
pcopy = p - back
cnt += 1
num += 1
return cnt
p_min = 0
p_max = 100000 * 10000
def biSearch(p_min, p_max):
p = p_max - p_min
if p_max - p_min <= 1:
return p_max
if p % 2 == 0:
c = p_min + int(p/2)
else:
c = p_min + int((p+1)/2)
v = capa(c,k)
if v < n:
p_min = c
else:
p_max = c
return biSearch(p_min, p_max)
p = biSearch(p_min, p_max)
n_init = n
while n_init <= n:
p -= 1
n = capa(p,k)
print((p+1))
| p02270 |
def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
heaviest_baggage = max(baggage)
average_capacity = sum(baggage) // truck_num
capacity = max(heaviest_baggage, average_capacity)
while carriable_baggage(baggage, baggage_num, capacity, truck_num) < baggage_num:
capacity += 1
return capacity
import sys
baggage_num, truck_num = list(map(int, sys.stdin.readline().split()))
baggage = list(map(int, sys.stdin))
capacity = min_capacity(baggage, baggage_num, truck_num)
print(capacity) | def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
left = 0
right = 10000 * baggage_num
while right - left > 1:
mid = (left + right) // 2
v = carriable_baggage(baggage, baggage_num, mid, truck_num)
if v >= baggage_num:
right = mid;
else:
left = mid
return right
import sys
n, k = list(map(int, sys.stdin.readline().split()))
T = list(map(int, sys.stdin))
P = min_capacity(T, n, k)
print(P) | p02270 |
def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
left = 0
right = 10000 * baggage_num
while right - left > 1:
mid = (left + right) // 2
v = carriable_baggage(baggage, baggage_num, mid, truck_num)
if v >= baggage_num:
right = mid;
else:
left = mid
return right
import sys
n, k = list(map(int, sys.stdin.readline().split()))
T = list(map(int, sys.stdin))
P = min_capacity(T, n, k)
print(P) | def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
heaviest_baggage = max(baggage)
left = 0
right = heaviest_baggage * baggage_num
while right - left > 1:
mid = (left + right) // 2
v = carriable_baggage(baggage, baggage_num, mid, truck_num)
if v >= baggage_num:
right = mid;
else:
left = mid
return right
import sys
n, k = list(map(int, sys.stdin.readline().split()))
T = list(map(int, sys.stdin))
P = min_capacity(T, n, k)
print(P) | p02270 |
def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
left = 0
right = max(baggage) * baggage_num
while right - left > 1:
mid = (left + right) // 2
v = carriable_baggage(baggage, baggage_num, mid, truck_num)
if v >= baggage_num:
right = mid;
else:
left = mid
return right
import sys
n, k = list(map(int, sys.stdin.readline().split()))
T = list(map(int, sys.stdin))
P = min_capacity(T, n, k)
print(P) | def carriable_baggage(baggage, baggage_num, truck_capacity, truck_num):
"""Return the number of baggae which trucks can carry."""
laden_baggage = 0
for i in range(truck_num):
laden_weight = 0
while laden_weight + baggage[laden_baggage] <= truck_capacity:
laden_weight += baggage[laden_baggage]
laden_baggage += 1
if laden_baggage == baggage_num:
return baggage_num
return laden_baggage
def min_capacity(baggage, baggage_num, truck_num):
"""Return the minimum value of maximum load capacity of trucks."""
left = 0
right = 10000 * baggage_num
while right - left > 1:
mid = (left + right) // 2
v = carriable_baggage(baggage, baggage_num, mid, truck_num)
if v >= baggage_num:
right = mid;
else:
left = mid
return right
import sys
n, k = list(map(int, sys.stdin.readline().split()))
T = list(map(int, sys.stdin))
P = min_capacity(T, n, k)
print(P) | p02270 |
import sys
def f(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.read().splitlines()))
l=0;r=n*100000
while r-l>1:
m=(l+r)//2
if f(m)>=n:r=m
else:l=m
print(r)
| import sys
def f(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.read().splitlines()))
l=0;r=sum(w)
while r-l>1:
m=(l+r)//2
if f(m)>=n:r=m
else:l=m
print(r)
| p02270 |
import sys
def f(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.read().splitlines()))
l=0;r=sum(w)
while r-l>1:
m=(l+r)//2
if f(m)>=n:r=m
else:l=m
print(r)
| import sys
def f(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.readlines()))
l=0;r=sum(w)
while r-l>1:
m=(l+r)//2
if f(m)>=n:r=m
else:l=m
print(r)
| p02270 |
import sys
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.readlines()))
def f():
i=0
for _ in[0]*k:
s=0
while s+w[i]<=m:
s+=w[i];i+=1
if i==n:return n
return i
l,r=max(w),sum(w)
while l<r:
m=(l+r)//2
if f()>=n:r=m
else:l=m+1
print(r)
| import sys
def s():
n,k=list(map(int,input().split()))
w=list(map(int,sys.stdin.readlines()))
def f():
c=t=0
for j in w:
t+=j
if t>m:
t=j
c+=1
if c>=k:return 0
return 1
l,r=max(w),sum(w)
while l<r:
m=(l+r)//2
if f():r=m
else:l=m+1
print(r)
if'__main__'==__name__:s()
| p02270 |
num, track = [int(x) for x in input().split()]
hoge_l = list()
for _ in range(num):
hoge_l.append(int(eval(input())))
hoge_i = sum(hoge_l)
if hoge_i % track == 0:
hoge_i = hoge_i // track
else:
hoge_i = hoge_i // track + 1
while True:
tmp = 0
c = 1
for v in hoge_l:
tmp += v
if tmp > hoge_i:
c += 1
tmp = 0
tmp += v
if c == track:
break
elif c > track:
hoge_i += 1
max_num = max(hoge_l)
if max_num > hoge_i:
hoge_i = max_num
print (hoge_i)
| def imas(hoge_l, p, track):
s_weights = 0
now_track = 1
for val in hoge_l:
s_weights += val
if s_weights > p:
s_weights = val
now_track += 1
if now_track > track:
return False
return True
num, track = [int(x) for x in input().split()]
hoge_l = list()
for _ in range(num):
hoge_l.append(int(eval(input())))
left = 0
right = 100000 * 10000
while left < right :
mid = (right + left) // 2
if imas(hoge_l, mid, track):
right = mid
else:
left = mid + 1
max_num = max(hoge_l)
if max_num > right:
right = max_num
print (right)
| p02270 |
global N,K
global ws
def check(max_p):
track=0
now=0
for i in range (N):
if(ws[i]>max_p):return False
if(now+ws[i]>max_p):
track+=1
now=ws[i]
else:
now+=ws[i]
if now>0:
track+=1
if(track>K):
return False
else:
return True
N,K=list(map(int,input().split()))
ans=0
now=0
ws=[]
for i in range(N):
w=int(eval(input()))
ws.append(w)
amin=0
amax=int(1E100)
while amin+1!=amax:
amid=(amin+amax)//2
if(check(amid)):
amax=amid
else:
amin=amid
print(amax)
|
global N,K
global ws
def check(max_p):
track=0
now=0
for i in range (N):
if(ws[i]>max_p):return False
if(now+ws[i]>max_p):
track+=1
now=ws[i]
else:
now+=ws[i]
if now>0:
track+=1
if(track>K):
return False
else:
return True
N,K=list(map(int,input().split()))
ans=0
now=0
ws=[]
for i in range(N):
w=int(eval(input()))
ws.append(w)
amin=0
amax=int(1E30)
while amin+1!=amax:
amid=(amin+amax)//2
if(check(amid)):
amax=amid
else:
amin=amid
print(amax)
| p02270 |
import math
n, k = list(map(int, input().split()))
a = [int(eval(input())) for _ in [None]*n]
lb = max(a)
ub = lb * n
while True:
mid = (ub+lb) // 2
remain = k - 1
cw = 0
for w in a:
cw += w
if cw > mid:
remain -= 1
cw = w
if remain < 0:
break
if remain < 0:
if lb == mid:
print((lb+1))
break
lb = mid
else:
if lb == mid:
print(lb)
break
ub = mid | def solve():
import sys
n, k = list(map(int, input().split()))
ws = tuple(map(int, sys.stdin))
ok, ng = sum(ws), max(ws)-1
while ok-ng > 1:
mid = (ok+ng+1)//2
current = 0
count = 0
for w in ws:
if current + w > mid:
current = w
count += 1
else:
current += w
if count < k:
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
solve()
| p02270 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import math
def is_loadable(load, num_truck, w_list):
excess = load*num_truck - sum(w_list)
#print('Minimum Load:', load, num_truck, 'excess:', excess)
cur_load = 0
#truck_load = list()
for w in w_list:
#print(cur_load, w)
if cur_load + w < load:
cur_load += w
elif cur_load + w == load:
#truck_load.append(cur_load + w)
cur_load = 0
num_truck -= 1
if num_truck < 0:
return False
else:
num_truck -= 1
if num_truck < 0:
return False
excess += load - cur_load
if excess < 0:
return False
#print(cur_load, 'is added')
#truck_load.append(cur_load)
cur_load = w
#truck_load.append(cur_load)
if (cur_load and num_truck == 0):
return False
#print(truck_load)
return True
n, num_truck = list(map(int, sys.stdin.readline().split()))
weight = list()
for i in range(n):
weight.append(int(sys.stdin.readline()))
ave_w = sum(weight) / num_truck
max_w = max(weight)
load = max(max_w, math.ceil(ave_w))
while True:
if is_loadable(load, num_truck, weight):
break
load += 1
print(load)
| #!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import math
def is_loadable(load, num_truck, w_list):
excess = load*num_truck - sum(w_list)
# print('Minimum Load:', load, num_truck, 'excess:', excess)
cur_load = 0
#truck_load = list()
for w in w_list:
#print(cur_load, w)
if cur_load + w < load:
cur_load += w
elif cur_load + w == load:
#truck_load.append(cur_load + w)
cur_load = 0
num_truck -= 1
if num_truck < 0:
return False
else:
num_truck -= 1
if num_truck < 0:
return False
excess += load - cur_load
if excess < 0:
return False
#print(cur_load, 'is added')
#truck_load.append(cur_load)
cur_load = w
#truck_load.append(cur_load)
if (cur_load and num_truck == 0):
return False
#print(truck_load)
return True
n, num_truck = list(map(int, sys.stdin.readline().split()))
weight = list()
for i in range(n):
weight.append(int(sys.stdin.readline()))
ave_w = sum(weight) / num_truck
max_w = max(weight)
load = max(max_w, math.ceil(ave_w))
max_ng = load - 1
while True:
if is_loadable(load, num_truck, weight):
break
min_ng = load
load += 1024
min_ok = load
while True:
if min_ok == max_ng + 1:
break
load = (max_ng + min_ok) // 2
if is_loadable(load, num_truck, weight):
min_ok = load
else:
max_ng = load
print(min_ok)
| p02270 |
n,k = [int(s) for s in input().split()]
#n,k = [int(s) for s in data.pop().split()]
w_org = []
[w_org.append(int(eval(input()))) for i in range(n)]
#[w_org.append(int(data.pop())) for i in range(n)]
def can(p_org,k):
p = p_org
w = w_org[:]
while k and w:
ww = w[0]
if ww <= p:
p -= ww
w.pop(0)
else:
p = p_org
k -= 1
if p == 0:
p = p_org
k -= 1
#print(ww,k,p)
return not(w)
left,right = max(w_org)-1,sum(w_org)+1
while left+1 < right:
middle = (left+right) // 2
if can(middle,k):
right = middle
else:
left = middle
print(right) | n,k = [int(s) for s in input().split()]
#n,k = [int(s) for s in data.pop().split()]
#n,k = 100000,100000
w_org = []
[w_org.append(int(eval(input()))) for i in range(n)]
#[w_org.append(int(data.pop())) for i in range(n)]
#w_org = [1 for i in range(n)]
def can(p_org,k):
p = p_org
w = w_org[::-1]
while k and w:
ww = w[-1]
if ww <= p:
p -= ww
w.pop()
else:
p = p_org
k -= 1
if p == 0:
p = p_org
k -= 1
#print(ww,k,p)
return not(w)
left,right = max(w_org)-1,sum(w_org)+1
roop = 0
while left+1 < right:
roop += 1
middle = (left+right) // 2
if can(middle,k):
right = middle
else:
left = middle
print(right) | p02270 |
#ALDS1_4-D Allocation
from collections import deque
def pIsAccptbl(w,k,p):
tr = 0
c = 0
while(w):
tmp = w.popleft()
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
c+=1
if c>k:
return False
else:
return True
n,k = input().split()
w = []
for i in range(int(n)):
w.append(int(eval(input())))
p = max(w)
while(1):
x=deque(w)
if(pIsAccptbl(x,int(k),p)):
print(p)
break
else:
p+=1 | #ALDS1_4-D Allocation
from collections import deque
def pIsAccptbl(w,k,p):
tr = 0
c = 0
while(w):
tmp = w.popleft()
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
if c+1>k:return False
return True
n,k = input().split()
w = []
for i in range(int(n)):
w.append(int(eval(input())))
p = max(w)
while(1):
x=deque(w)
if(pIsAccptbl(x,int(k),p)):
print(p)
break
else:
p+=1 | p02270 |
from collections import deque
def cndP(l,n,p1,p2):
d = set()
min = sum(l[:])
length = len(l)
for i in range(length-n+1):
s = sum(l[i:i+n])
if s < min:
min = s
if p2 == None:
if p1 < s:
d.add(s)
else:
if p1 < s < p2:
d.add(s)
d.add(min)
return sorted(d)
def pIsAccptbl(w,k,p):
tr = 0
c = 0
d = deque(w)
while(d):
tmp = d.popleft()
if(tmp > p):
return False
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
if c+1>k:
return False
return True
n,k = [int(x) for x in input().split()]
w = []
for i in range(n):
e = int(eval(input()))
w.append(e)
p = max(w)
if(pIsAccptbl(w,k,p)):
print(p)
else:
n=2
p1 = p
p2 = None
while(1):
s = cndP(w,n,p1,p2)
if not p2 == None:
if s[0] > p2:
print(p2)
break
for i in s:
if(pIsAccptbl(w,k,i)):
p2 = i
break
if(p2==None):
p1 = i
if (n == len(w)):
print(p2)
break
n+=1 | from collections import deque
import sys
sys.setrecursionlimit(100000)
def copyDeque(d):
x = deque()
for i in d:
x.append(i)
return x
def cndP(w):
if len(w)>1:
x = w.pop()
cndP(copyDeque(w))
w.append(x)
s = 0
while(len(w)>0):
s += w.pop()
st.add(s)
else:
st.add(w[0])
def pIsAccptbl(w,k,p):
tr = 0
c = 0
d = copyDeque(w)
while(d):
tmp = d.popleft()
if(tmp > p):
return False
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
if c+1>k:
return False
return True
n,k = [int(x) for x in input().split()]
w = deque()
for i in range(n):
w.append(int(eval(input())))
st = set()
cndP(copyDeque(w))
sorted_st = sorted(st)
for i in sorted_st:
if pIsAccptbl(w,k,i):
print(i)
break | p02270 |
from collections import deque
def isPa(w,k,p):
tr = 0
c = 0
d = deque(w)
while(d):
tmp = d.popleft()
if(tmp > p):
return False
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
if c+1>k:
return False
return True
def MaxInP(w,k,p):
maxinp = 0
tmp = 0
d = deque(w)
while(d):
tmp += d.popleft();
if(tmp > p):
if(tmp > maxinp):
maxinp = tmp
tmp = 0
return maxinp
n,k = [int(x) for x in input().split()]
w = deque()
for i in range(n):
w.append(int(eval(input())))
mean = int(sum(w)/k)
maxinp = MaxInP(w,k,mean)
if k == 1:
print(mean)
else:
minP = mean
maxP = maxinp
while(True):
m = int ((minP + maxP)/2)
if ( isPa(w,k,m) ):
maxP = m
else:
minP = m
if (minP+1 == maxP):
print(maxP)
break | from collections import deque
def isPa(w,k,p):
tr = 0
c = 0
d = deque(w)
while(d):
tmp = d.popleft()
if(tmp > p):
return False
if( tr + tmp > p):
tr = tmp
c += 1
else:
tr += tmp
if c+1>k:
return False
return True
def MaxInP(w,k,p):
maxinp = 0
tmp = 0
d = deque(w)
while(d):
tmp += d.popleft();
if(tmp > p):
if(tmp > maxinp):
maxinp = tmp
tmp = 0
return maxinp
n,k = [int(x) for x in input().split()]
w = deque()
for i in range(n):
w.append(int(eval(input())))
mean = int(sum(w)/k)
maxinp = MaxInP(w,k,mean)
if k == 1:
print(mean)
else:
minP = mean
maxP = maxinp
while(True):
m = int ((minP + maxP)/2)
if ( isPa(w,k,m) ):
maxP = m
else:
minP = m
if (minP+1 == maxP or minP == maxP):
print(maxP)
break | p02270 |
n, k = [int(t) for t in input().split()]
w = [int(eval(input())) for i in range(n)]
hi = sum(w)
lo = max(w)
def canMove(w, P, k):
s = 0
for i in range(len(w)):
if s + w[i] > P:
s = 0
k -= 1
if k <= 0: return False
s += w[i]
return True
P = hi
while lo < hi:
m = (lo + hi) // 2
if canMove(w, m, k):
P = m
hi = m
else:
lo = m + 1
print(P)
| n, k = [int(t) for t in input().split()]
w = [int(eval(input())) for i in range(n)]
def canMove(w, P, k):
s = 0
for i in range(len(w)):
if s + w[i] > P:
s = 0
k -= 1
if k <= 0: return False
s += w[i]
return True
hi = sum(w)
lo = max(w)
P = hi
while lo < hi:
m = (lo + hi) // 2
if canMove(w, m, k):
P = m
hi = m
else:
lo = m + 1
print(P)
| p02270 |
n, k = list(map(int, input().split()))
ww = [int(eval(input())) for _ in range(n)]
def chk(p):
c = 1
s = 0
for w in ww:
if w > p:
return False
if s + w <= p:
s += w
else:
c += 1
s = w
if c > k:
return False
return True
def search(l, r):
if r - l < 10:
for i in range(l, r):
if chk(i):
return i
m = (l + r) // 2
if chk(m):
return search(l, m + 1)
else:
return search(m, r)
print((search(0, 2 ** 30))) | n, k = list(map(int, input().split()))
ww = [int(eval(input())) for _ in range(n)]
def chk(p):
c = 1
s = 0
for w in ww:
if w > p:
return False
if s + w <= p:
s += w
else:
c += 1
s = w
if c > k:
return False
return True
def search(l, r):
if r - l < 10:
for i in range(l, r):
if chk(i):
return i
m = (l + r) // 2
if chk(m):
return search(l, m + 1)
else:
return search(m + 1, r)
print((search(0, 2 ** 30))) | p02270 |
from functools import lru_cache
n, tracks = list(map(int, input().split()))
loads = []
for _ in range(n):
loads.append(int(eval(input())))
# print(loads)
slices = []
min_load = [99999999999999]
@lru_cache()
def slicing(rest, s=0):
if not rest:
# slices.append(s+[(len(s) and s[-1][1], len(loads))])
return sum(loads[s:])
result = 99999999999999
for s1 in range(s+1, len(loads)-rest+1):
sub_total = sum(loads[s: s1])
if sub_total > result:
break
result = min(result, max(sub_total, slicing(rest-1, s1)))
return result
rs = slicing(tracks-1)
print(rs)
# print(slices)
# def load_count_max(load):
# print(load, max(sum(loads[l[0]: l[1]]) for l in load))
# return max(sum(loads[l[0]: l[1]]) for l in load)
# result = min(map(load_count_max, slices))
# print(result)
| n, k = list(map(int, input().split()))
def check(p):
i = 0
for j in range(k):
s = 0
while s + T[i] <= p:
s += T[i]
i += 1
if i == n:
return n
return i
def solve():
left = 0
right = 100000 * 10000
while right - left > 1:
mid = (left + right) // 2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
return right
T = []
for _ in range(n):
T.append(int(eval(input())))
ans = solve()
print(ans)
| p02270 |
import sys
readline = sys.stdin.readline
N, K = list(map(int, input().split()))
W = tuple(int(readline()) for _ in range(N))
ma = max(W)
def check(x):
if x < ma:
return False
use = 1
rest = x
for w in W:
if rest >= w:
rest -= w
else:
rest = x - w
use += 1
return use <= K
l = 0
r = sum(W)
while r - l > 1:
m = (r + l) // 2
if check(m):
r = m
else:
l = m
print(r)
| import sys
readline = sys.stdin.readline
N, K = list(map(int, input().split()))
W = tuple(map(int, sys.stdin.read().splitlines()))
ma = max(W)
def check(x):
if x < ma:
return False
use = 1
rest = x
for w in W:
if rest >= w:
rest -= w
else:
rest = x - w
use += 1
return use <= K
l = 0
r = sum(W)
while r - l > 1:
m = (r + l) // 2
if check(m):
r = m
else:
l = m
print(r)
| p02270 |
def takein(p):
s = 0
track = 1
for i in range(n):
if s + w[i] <= p:
s += w[i]
else:
track += 1
if track > k: return False
s = w[i]
return True
n, k = list(map(int, input().strip().split()))
w = []
for i in range(n):
w.append(int(eval(input())))
p = max(max(w), sum(w) // k)
while not takein(p):
p += 1
print(p) | import sys
def check(p):
s = w[0]
track = 1
for i in range(1, n):
if s + w[i] <= p:
s += w[i]
else:
track += 1
if track > k: return False
s = w[i]
return True
n, k = list(map(int, sys.stdin.readline().strip().split()))
w = []
for i in range(n):
w.append(int(sys.stdin.readline()))
L = max(w)
if check(L):
print(L)
else:
R = sum(w)
assert check(R)
while L + 1 < R:
M = (L + R) // 2
if check(M):
R = M
else:
L = M
print(R) | p02270 |
n, k = list(map(int, input().split()))
l = []
for i in range(n):
d = int(eval(input()))
l.append(d)
p = max(l)
while True:
sm_k = 0
k_no = 1
for li in l:
if sm_k + li > p:
k_no += 1
sm_k = li
else:
sm_k += li
# print(p, k_no)
if k_no <= k:
print(p)
break
p += 1
| n, k = list(map(int, input().split()))
l = []
for i in range(n):
d = int(eval(input()))
l.append(d)
p = max(l)
while True:
sm_k = 0
k_no = 1
for li in l:
if sm_k + li > p:
k_no += 1
if k_no > k:
break
sm_k = li
else:
sm_k += li
# print(p, k_no)
if k_no <= k:
print(p)
break
p += 1
| p02270 |
# -*- coding: utf-8 -*-
import sys
import os
n, k = list(map(int, input().split()))
#print(k, '??°??§????????????')
W = []
for i in range(n):
W.append(int(eval(input())))
def check(P):
# ?????????P?????\?????¨??????????????????????????????????????????????????¢??°
weight_index = 0
for i in range(k):
current_weight = 0
while current_weight + W[weight_index] <= P:
#print('i', i, W[weight_index], '?????????')
current_weight += W[weight_index]
weight_index += 1
if weight_index == len(W):
# ??¨??¨?????£???
return len(W)
return weight_index
P_min = 1
P_max = sum(W)
P_mid = None
while True:
P_mid = (P_min + P_max) // 2
loaded_num = check(P_mid)
if loaded_num < n:
# ????????????????????????
P_min = P_mid
else:
# ??????????????????????????§???P??????????????¢???
P_max = P_mid
if P_max - P_min <= 1:
break
# ??????
if check(P_min) == n:
print(P_min)
else:
print(P_max) | # -*- coding: utf-8 -*-
import sys
import os
n, k = list(map(int, input().split()))
#print(k, '??°??§????????????')
W = []
for i in range(n):
W.append(int(eval(input())))
def check(P):
# ?????????P?????\?????¨??????????????????????????????????????????????????¢??°
weight_index = 0
for i in range(k):
current_weight = 0
while current_weight + W[weight_index] <= P:
#print('i', i, W[weight_index], '?????????')
current_weight += W[weight_index]
weight_index += 1
if weight_index == len(W):
# ??¨??¨?????£???
return len(W)
return weight_index
P_min = 1
P_max = sum(W)
P_mid = None
while True:
P_mid = (P_min + P_max) // 2
loaded_num = check(P_mid)
if loaded_num < n:
# ????????????????????????
P_min = P_mid + 1
else:
# ??????????????????????????§???P??????????????¢???
P_max = P_mid
if P_max == P_min:
break
# ??????
print(P_max) | p02270 |
class Solve:
def __init__(self):
self.N, self.K = [int(i) for i in input().split()]
self.W = [int(eval(input())) for i in range(self.N)]
self.a = max(self.W)-1 # >= 0; False
self.b = sum(self.W) # <= 10**9; True
def check(self, P):
k, p, W = 1, P, [w for w in self.W]
while W:
if p >= W[0]:
p -= W.pop(0)
elif k < self.K:
k, p = k+1, P
else:
return False
return True
def solve(self):
while self.b - self.a > 1:
m = (self.a + self.b) // 2
if self.check(m):
self.b = m
else:
self.a = m
return self.b
print((Solve().solve())) |
class Solve:
def __init__(self):
self.N, self.K = [int(i) for i in input().split()]
self.W = [int(eval(input())) for i in range(self.N)]
self.a = max(self.W)-1 # >= 0; False
self.b = sum(self.W) # <= 10**9; True
def check(self, P):
k, p, W = 1, P, [w for w in self.W]
for w in W:
if p >= w:
p -= w
elif P >= w and k < self.K:
k, p = k+1, P-w
else:
return False
return True
def solve(self):
while self.b - self.a > 1:
m = (self.a + self.b) // 2
if self.check(m):
self.b = m
else:
self.a = m
return self.b
print((Solve().solve())) | p02270 |
n, k = list(map(int, input().split()))
w = [int(eval(input())) for i in range(n)]
def f(P):
mx = k * P
total = 0
for i in range(n):
tmp = total + w[i]
if tmp > mx:
return i
else:
total = tmp
return n
def f(P):
i = 0
for j in range(k):
s = 0
while s + w[i] <= P:
s += w[i]
i += 1
if i == n: return n
return i
P = 0
l = list(range(sum(w)))
while f(P) < n:
P += 1
print(P)
| n, k = list(map(int, input().split()))
w = [int(eval(input())) for i in range(n)]
def f(P):
i = 0
for j in range(k):
s = 0
while s + w[i] <= P:
s += w[i]
i += 1
if i == n: return n
return i
left = 0
right = 100000 * 10000
while right - left > 1:
mid = (left + right) // 2
v = f(mid)
if v>=n:right=mid
else: left = mid
print (right) | p02270 |
import math, sys
def loadable(w, n, k, p, wsum):
wait = 0
for i in range(n):
wait += w[i]
wsum -= w[i]
if wait > p:
k -= 1
wait = w[i]
if k == 0 or p < wsum / k:
return False
return True
n, k = list(map(int, sys.stdin.readline().split()))
w = [int(sys.stdin.readline()) for _ in range(n)]
wsum = sum(w)
p = max(int(math.ceil(wsum / k)), max(w))
pre_f = p -1
pre_s = None
while True:
if loadable(w, n, k, p, wsum):
if p - pre_f == 1:
break
pre_s = p
p = int((p + pre_f) /2)
else:
pre_f = p
if pre_s:
p = int((pre_s + p) / 2)
else:
p = math.ceil(p * 1.01)
print(p) | import math, sys
def loadable(w, n, k, p, wsum):
wait = 0
for i in range(n):
wait += w[i]
wsum -= w[i]
if wait > p:
k -= 1
wait = w[i]
if k == 0 or p < wsum / k:
return False
return True
n, k = list(map(int, sys.stdin.readline().split()))
w = [int(sys.stdin.readline()) for _ in range(n)]
wsum = sum(w)
p = max(int(math.ceil(wsum / k)), max(w))
pre_f = p -1
pre_s = None
while True:
if loadable(w, n, k, p, wsum):
pre_s = p
else:
pre_f = p
if pre_s != None and pre_s - pre_f == 1:
break
if pre_s:
p = int((pre_s + pre_f) / 2)
else:
p = math.ceil(p * 1.01)
print(pre_s) | p02270 |
from itertools import combinations
n,k = list(map(int, input().split()))
k = min(n,k)
W = list(map(int,[eval(input()) for _ in range(n)]))
if k > 1:
P = 10001
for b in combinations(list(range(1,n)),k-1):
s = 0
Pi = 0
for i in b:
Pi = max(Pi, sum(W[s:i]))
s = i
P = min(P, max(Pi, sum(W[s:])))
print(P)
else:
print((sum(W))) | def checkCapacity(W,k,P):
ws = 0
cnt = 1
for wi in W:
if wi > P: return False
ws += wi
if ws > P:
cnt += 1
ws = wi
if cnt > k: return False
return True
if __name__=='__main__':
n,k = list(map(int, input().split()))
W = list(map(int,[eval(input()) for _ in range(n)]))
Pmax = sum(W)
Pmin = 0
while Pmin < Pmax:
P = (Pmax + Pmin) // 2
if checkCapacity(W,k,P):
Pmax = P
else:
Pmin = P + 1
print(Pmax) | p02270 |
def checkCapacity(W,k,P):
ws = 0
cnt = 1
for wi in W:
if wi > P: return False
ws += wi
if ws > P:
cnt += 1
ws = wi
if cnt > k: return False
return True
if __name__=='__main__':
n,k = list(map(int, input().split()))
W = list(map(int,[eval(input()) for _ in range(n)]))
Pmax = sum(W)
Pmin = 0
while Pmin < Pmax:
P = (Pmax + Pmin) // 2
if checkCapacity(W,k,P):
Pmax = P
else:
Pmin = P + 1
print(Pmax) | def checkCapacity(W,k,P):
ws = 0
cnt = 1
for wi in W:
ws += wi
if ws > P:
cnt += 1
ws = wi
if cnt > k: return False
return True
if __name__=='__main__':
n,k = list(map(int, input().split()))
W = list(map(int,[eval(input()) for _ in range(n)]))
Pmax = sum(W)
Pmin = max(W)
while Pmin < Pmax:
P = (Pmax + Pmin) // 2
if checkCapacity(W,k,P):
Pmax = P
else:
Pmin = P + 1
print(Pmax) | p02270 |
from math import ceil
s = input().split(" ")
n = int(s[0])
k = int(s[1])
w = []
total = 0
for i in range(n):
a = int(eval(input()))
w.append(a)
total += a
mx = max(ceil(total / k), max(w))
while True:
t = []
t.append(w[0])
for i in range(1,len(w)):
if t[len(t)-1] + w[i] <= mx:
t[len(t)-1] += w[i]
else:
t.append(w[i])
if len(t) > k:
break
if len(t) > k:
mx += 1
else:
break
print(mx) | def check(P,w,n):
i = 0
for j in range(k):
s = 0
while s + w[i] <= P:
s += w[i]
i += 1
if i == n:
return n
return i
s = input().split(" ")
n = int(s[0])
k = int(s[1])
w = []
for i in range(n):
a = int(eval(input()))
w.append(a)
left = 0
right = 100000 * 10000
while right - left > 1:
mid = int((right + left) / 2)
v = check(mid,w,n)
if v >= n:
right = mid
else:
left = mid
print(right) | p02270 |
n, k = list(map(int, input().split(' ')))
w_s = [int(eval(input())) for i in range(n)]
max_w = max(w_s)
while True:
tmp_total_w = 0
tmp_k = 1
for w in w_s:
tmp_total_w += w
if tmp_total_w > max_w:
tmp_k += 1
tmp_total_w = w
if tmp_k <= k:
break
max_w += 1
print(max_w)
| def calc_k_constP(P):
tmp_total_w = 0
tmp_k = 1
for w in w_s:
tmp_total_w += w
if tmp_total_w > P:
tmp_k += 1
tmp_total_w = w
return tmp_k
n, k = list(map(int, input().split(' ')))
w_s = [int(eval(input())) for i in range(n)]
max_w = max(w_s)
left, right = max_w, 10000 * n
while left < right:
mid = (right + left) // 2
tmp_k = calc_k_constP(mid)
if tmp_k <= k:
right = mid
else:
left = mid + 1
print(left)
| p02270 |
def binary_search(n, k, lw):
left = 0
right = max(lw) * n
while left <= right:
mid = (left + right)//2
if is_underweight(n, k, lw, p=mid):
right = mid - 1
else:
left = mid + 1
if is_underweight(n, k, lw, p=right):
return right
else:
return left
def is_underweight(n, k, lw, p):
i = 0
w = 0
ck = 1
while i < n:
if lw[i] > p:
return False
rest = p - w
if lw[i] <= rest:
w += lw[i]
i += 1
else:
w = 0
ck += 1
return ck <= k
def main():
n, k = list(map(int, input().split()))
lw = []
for _ in range(n):
lw.append(int(eval(input())))
p = binary_search(n, k, lw)
print(p)
if __name__ == '__main__':
main()
| def binary_search(n, k, lw):
left = 0
right = max(lw) * n
while left < right:
mid = (left + right)//2
if is_underweight(n, k, lw, p=mid):
right = mid
else:
left = mid + 1
return left
def is_underweight(n, k, lw, p):
i = 0
w = 0
ck = 1
while i < n:
if lw[i] > p:
return False
rest = p - w
if lw[i] <= rest:
w += lw[i]
i += 1
else:
w = 0
ck += 1
return ck <= k
def main():
n, k = list(map(int, input().split()))
lw = []
for _ in range(n):
lw.append(int(eval(input())))
p = binary_search(n, k, lw)
print(p)
if __name__ == '__main__':
main()
| p02270 |
def check_alloc(weights, cnt, cpct, st, stn):
num = 1
cur = stn
for i in range(st, len(weights)):
w = weights[i]
if cur + w > cpct:
if num == 1:
st = i
stn = cur
cur = w
num += 1
if num > cnt or cur > cpct:
return False
else:
cur += w
return True
n, k = list(map(int, input().split()))
weights = [0] * n
cpct = 0
for i in range(n):
weight = int(eval(input()))
weights[i] = weight
cpct += weight
cpct = int(cpct/k)
st = 0
stn = 0
while True:
can_alloc = check_alloc(weights, k, cpct, st, stn)
if can_alloc == False:
cpct += 1
else:
break
print(cpct)
| import sys
def check_alloc(weights, cnt, cpct):
num = 1
cur = 0
for i in range(len(weights)):
w = weights[i]
if cur + w > cpct:
cur = w
num += 1
if num > cnt or cur > cpct:
return False
else:
cur += w
return True
n, k = list(map(int, input().split()))
weights = [0] * n
sum = 0
maxi = 0
for i in range(n):
weight = int(eval(input()))
weights[i] = weight
sum += weight
maxi = max(maxi, weight)
if k == 1:
print(sum)
sys.exit()
start = maxi
end = sum
mid = 0
while start <= end:
mid = int(start + (end - start) / 2)
can_alloc = check_alloc(weights, k, mid)
if can_alloc == False:
start = mid + 1
else:
if start == end: break
end = mid
print(mid)
| p02270 |
def calc_k(p, ws):
k = 1
s = 0
for w in ws:
if s + w <= p:
s += w
else:
k += 1
s = w
return k
def search_minimum_p_internal(lp, rp, k, ws):
"?????????P????????????????????¢?´¢??????"
cp = (lp + rp) // 2
k1 = calc_k(cp, ws)
if k1 == k:
# ???????????¨????????????????°?????????¨???k??°????????????????????????
return cp
elif k1 < k:
# ???????????¨???????????????k??°???????°?????????????????????§????????????????????????????????????
return search_minimum_p_internal(lp, cp - 1, k, ws)
else:
# ???????????¨???????????????k??°????????????????????????????????????????????????????¶?????????????
return search_minimum_p_internal(cp + 1, rp, k, ws)
def search_minimum_p(k, ws):
"""
max(P) = max(wi) * max(n)
????????¨???????????????1??°?????¨????????????????????????
min(P) = max(wi)
?°?????????¨??????????????????????????§????????????????????????????????????
"""
maxp = 10000 * 100000
minp = max(ws)
p = search_minimum_p_internal(minp, maxp, k, ws)
while True:
k1 = calc_k(p - 1, ws)
if k1 == k and p > minp:
p -= 1
else:
return p
n, k = list(map(int, input().split()))
ws = []
for i in range(n):
ws.append(int(eval(input())))
print((search_minimum_p(k, ws))) | def calc_k(p, ws):
k = 1
s = 0
for w in ws:
if w > p:
return None
elif s + w <= p:
s += w
else:
k += 1
s = w
return k
def search_minimum_p(k, ws):
"""
?????????P????????????????????¢?´¢??????
max(P) = max(wi) * max(n)
????????¨???????????????1??°?????¨????????????????????????
min(P) = max(wi)
?°?????????¨??????????????????????????§????????????????????????????????????
"""
lp = max(ws)
rp = 10000 * 100000
while lp <= rp:
cp = (lp + rp) // 2
k1 = calc_k(cp, ws)
if k1 <= k:
# ???????????¨???????????????k??°??\????????????????????§??????
k2 = calc_k(cp - 1, ws)
if k2 == None or k2 > k:
# cp???k??°???????????????????????????p???????°??????§??????
return cp
else:
# ???????°???????p????????¨??????
rp = cp - 1
else:
# ???????????¨???????????????k??°????????????????????????????????????????????????????¶?????????????
lp = cp + 1
return None
n, k = list(map(int, input().split()))
ws = []
for i in range(n):
ws.append(int(eval(input())))
print((search_minimum_p(k, ws))) | p02270 |
n, k = list(map(int, input().split()))
w = [int(eval(input())) for i in range(n)]
l = max(w)
r = sum(w)
while l < r:
m = (l + r) // 2
stack = car = 0
for i in w:
stack += i
if stack > m:
stack = i
car += 1
if car < k:
r = m
else:
l = m + 1
print(l) | import sys
n, k = list(map(int, input().split()))
w = [int(sys.stdin.readline()[:-1]) for i in range(n)]
l = max(w)
r = sum(w)
while l < r:
m = (l + r) // 2
stack = car = 0
for i in w:
stack += i
if stack > m:
stack = i
car += 1
if car < k:
r = m
else:
l = m + 1
print(l) | p02270 |
from math import ceil
def check_p(p):
global k, ws
ct, nt = 0, 1
for w in ws:
if ct + w <= p:
ct += w
else:
nt += 1
if nt > k:
return False
ct = w
return True
n, k = list(map(int, input().split()))
ws = [int(eval(input())) for _ in range(n)]
p = max(ceil(sum(ws) / k), *ws)
while True:
if check_p(p):
break
p += 1
print(p) | def check_p(p):
global k, ws
ct, nt = 0, 1
for w in ws:
if ct + w <= p:
ct += w
else:
nt += 1
if nt > k:
return False
ct = w
return True
n, k = list(map(int, input().split()))
ws = [int(eval(input())) for _ in range(n)]
l, r, p = max(ws), sum(ws), 0
while l < r:
p = (l + r) // 2
if check_p(p):
r = p
else:
l = p = p + 1
print(p) | p02270 |
def check_p(p):
global k, ws
ct, nt = 0, 1
for w in ws:
if ct + w <= p:
ct += w
else:
nt += 1
if nt > k:
return False
ct = w
return True
n, k = list(map(int, input().split()))
ws = [int(eval(input())) for _ in range(n)]
l, r, p = max(ws), sum(ws), 0
while l < r:
p = (l + r) // 2
if check_p(p):
r = p
else:
l = p = p + 1
print(p) | def check_p(p):
global k, ws
lt, nt = 0, 1 # loadage_of_current_truck, num_of_truck
for w in ws:
lt += w
if lt > p:
nt += 1
if nt > k:
return False
lt = w
return True
n, k = list(map(int, input().split()))
ws = [int(eval(input())) for _ in range(n)]
l, r, p = max(ws), sum(ws), 0
while l < r:
p = (l + r) // 2
if check_p(p):
r = p
else:
l = p = p + 1
print(p) | p02270 |
def calc_allocatable_packet(packets, num_of_trucks, p_max):
""" ?????????????????°?????????????????§?????????????±?????????????n??°??????????????????????????????????????°????±??????? """
num_of_packets = len(packets)
next_p = 0 # ?????°?????????????????° ??? ?¬????packet[i]?????????????????????
for t in range(num_of_trucks):
payload = 0 # ??????????????????????????????
while next_p < num_of_packets:
if payload + packets[next_p] <= p_max: # ?¬?????????????????????§???????
payload += packets[next_p]
next_p += 1
else:
break # ?¬???????????????????
return next_p
def get_ball_park_estimate(packets, num_of_trucks):
num_of_packets = len(packets)
upper_limit = 10000 * num_of_packets
result = calc_allocatable_packet(packets, num_of_trucks, upper_limit)
while result >= num_of_packets:
upper_limit //= 2
result = calc_allocatable_packet(packets, num_of_trucks, upper_limit)
return upper_limit // 2, upper_limit
def calc_minimum_payload(packets, num_of_trucks):
lower_limit, upper_limit = get_ball_park_estimate(packets, num_of_trucks)
num_of_packets = len(packets)
p_max = lower_limit
result = calc_allocatable_packet(packets, num_of_trucks, p_max)
while result < num_of_packets:
p_max += 1
result = calc_allocatable_packet(packets, num_of_trucks, p_max)
return p_max
#num_of_packets = len(packets)
#p_max = packets[0]
#result = calc_allocatable_packet(packets, num_of_trucks, p_max)
#while result < num_of_packets:
# p_max += 1
# result = calc_allocatable_packet(packets, num_of_trucks, p_max)
#return p_max
if __name__ == '__main__':
# ??????????????\???
num_of_packets, num_of_trucks = [int(x) for x in input().split(' ')]
packets = [int(eval(input())) for _ in range(num_of_packets)]
# packets = [8, 1, 7, 3, 9]
# ???????????????
result = calc_minimum_payload(packets, num_of_trucks)
# ???????????¨???
print(result) | def calc_allocatable_packet(packets, num_of_trucks, p_max):
""" ?????????????????°?????????????????§?????????????±?????????????n??°??????????????????????????????????????°????±??????? """
num_of_packets = len(packets)
next_p = 0 # ?????°?????????????????° ??? ?¬????packet[i]?????????????????????
for t in range(num_of_trucks):
payload = 0 # ??????????????????????????????
while next_p < num_of_packets:
if payload + packets[next_p] <= p_max: # ?¬?????????????????????§???????
payload += packets[next_p]
next_p += 1
else:
break # ?¬???????????????????
return next_p
def calc_minimum_payload(packets, num_of_trucks):
num_of_packets = len(packets)
lower_limit = packets[0]
upper_limit = 10000 * num_of_packets
while lower_limit < upper_limit:
middle = (lower_limit + upper_limit) // 2
result = calc_allocatable_packet(packets, num_of_trucks, middle)
if result < num_of_packets:
lower_limit = middle + 1
else:
upper_limit = middle
return lower_limit
if __name__ == '__main__':
# ??????????????\???
num_of_packets, num_of_trucks = [int(x) for x in input().split(' ')]
packets = [int(eval(input())) for _ in range(num_of_packets)]
# num_of_packets, num_of_trucks = 0, 0
# packets = []
# with open('ALDS1_4_D_in25.txt') as f:
# for line in f:
# if ' ' not in line:
# packets.append(int(line))
# else:
# num_of_packets, num_of_trucks = [int(x) for x in line.split(' ')]
# ???????????????
result = calc_minimum_payload(packets, num_of_trucks)
# ???????????¨???
print(result) | p02270 |
import sys
n, k = list(map(int, input().split()))
ws = list(map(int, sys.stdin.read().split()))
h = sum(ws)
p = h // k
def isEnough(A, n, k, w):
ps = [w for x in range(k)]
j = 0
for i in range(n):
a = A[i]
p = ps[j]
if p < a:
j += 1
if j < k:
p = ps[j]
else:
return False
dif = p - a
if dif < 0:
return False
else:
ps[j] = dif
return True
while not isEnough(ws, n, k, p):
p += 1
print(p) | import sys
n, k = list(map(int, input().split()))
ws = list(map(int, sys.stdin.read().split()))
h = sum(ws)
p = h // k
def isEnough(A, n, k, w):
one = w
count = 0
for a in A:
if one < a:
count += 1
if count < k:
one = w
else:
return False
dif = one - a
if dif < 0:
return False
else:
one = dif
return True
while not isEnough(ws, n, k, p):
p += 1
print(p) | p02270 |
import sys
import math
def check_sekisairyo(k, p_min, w_i):
p_now = 0
k_now = 0
for w in w_i:
p_now += w
if p_now > p_min:
p_now = w
k_now += 1
elif p_now == p_min:
p_now = 0
k_now += 1
if k_now == k and p_now != 0:
return False
return True
n, k = list(map(int, input().split()))
w_i = [int(eval(input())) for i in range(n)]
p_min = math.floor(sum(w_i) / k)
w_max = max(w_i)
if p_min < w_max:
p_min = w_max
while not check_sekisairyo(k, p_min, w_i):
p_min += 1
print(p_min) | import sys
def check_sekisairyo(p_min):
p_now = 0
k_now = 0
for w in w_i:
p_now += w
if p_now > p_min:
p_now = w
k_now += 1
elif p_now == p_min:
p_now = 0
k_now += 1
if k_now == k and p_now != 0:
return False
return True
n, k = list(map(int, input().split()))
w_i = [int(eval(input())) for i in range(n)]
left, right, p_min = max(w_i), sum(w_i), 0
while left < right:
p_min = (left + right) // 2
if check_sekisairyo(p_min):
right = p_min
else:
left = p_min = p_min + 1
print(p_min) | p02270 |
def p(k,w,maxP):
count = 1
tmpList = []
for x in w:
if sum(tmpList)+x <= maxP:
tmpList.append(x)
else:
count += 1
if count > k :
return False
tmpList = []
tmpList.append(x)
return True
n,k = list(map(int,input().split()))
w = []
for _ in range(n):
w.append((int)(eval(input())))
rangeMax = sum(w)
rangeMin = max(w)
rangeMid = 0
while rangeMin < rangeMax:
rangeMid = (rangeMax + rangeMin)//2
'''print(p(k,w,rangeMid))
print(p(k,w,rangeMid+1))
print("---")
'''
if p(k,w,rangeMid) == True:
rangeMax = rangeMid
else:
rangeMid += 1
rangeMin = rangeMid
print(rangeMid) |
def p(k,w,maxP):
count = 1
tmpWeight = 0
for x in w:
if tmpWeight+x <= maxP:
tmpWeight += x
else:
count += 1
if count > k :
return False
tmpWeight = x
return True
n,k = list(map(int,input().split()))
w = []
for _ in range(n):
w.append((int)(eval(input())))
rangeMax = sum(w)
rangeMin = max(w)
rangeMid = 0
while rangeMin < rangeMax:
rangeMid = (rangeMax + rangeMin)//2
'''print(p(k,w,rangeMid))
print(p(k,w,rangeMid+1))
print("---")
'''
if p(k,w,rangeMid) == True:
rangeMax = rangeMid
else:
rangeMid += 1
rangeMin = rangeMid
print(rangeMid) | p02270 |
import sys
n, k = list(map(int, input().split()))
w = tuple(map(int, sys.stdin.readlines()))
p = max(w)
s = sum(w)
if n <= k:
print(p)
elif k == 1:
print(s)
else:
a = max(p, s//k)
while True:
l = [a]
for i in range(n):
d = l[-1] - w[i]
if d < 0:
l.append(a-w[i])
else:
l[-1] = d
i += 1
if len(l) > k:
a += 1
else:
break
print(a) | n,k = list(map(int, input().split()))
w = [int(eval(input())) for _ in range(n)]
def check(p):
c = t = 0
for wi in w:
t += wi
if t > p:
t = wi
c += 1
if c >= k:
return False
return True
s = max(w)
l = sum(w)
m = l + (s-l)*k//n
while s < l:
if check(m):
l = m
else:
s = m+1
m = (s+l)//2
print(m) | p02270 |
import sys
import math
def is_capable(n, k, w, P):
track = 0
cnt = 0
i = 0
while cnt < k:
if i == n:
return True
if track + w[i] > P:
track = 0
cnt += 1
else:
track += w[i]
i += 1
return False
pass
# ??\?????¨
n, k = list(map(int, sys.stdin.readline().split()))
w = []
for i in range(n):
w.append(int(sys.stdin.readline().strip()))
'''
print(n,k)
print(w)
'''
# ????????¨
if k == 1:
ans = sum(w)
print(ans)
elif n == 1:
ans = w[0]
print(ans)
else:
max_p = sum(w)
min_p = math.ceil(max_p / k) - 1
# print(max_p, min_p)
# sys.exit(0)
capable = {min_p:False, max_p:True}
# sys.exit(0)
bottom = min_p
top = max_p
while bottom < top:
mid = (bottom + top) // 2
if mid not in capable:
capable[mid] = is_capable(n, k, w, mid)
if capable[mid] == True:
if (mid - 1) not in capable:
capable[mid - 1] = is_capable(n, k, w, mid - 1)
if capable[mid - 1] == False:
ans = mid
break
else:
top = mid
elif capable[mid] == False:
if (mid + 1) not in capable:
capable[mid + 1] = is_capable(n, k, w, mid + 1)
if capable[mid + 1] == True:
ans = mid + 1
break
else:
bottom = mid + 1
print(ans)
# print(capable) | import sys
import math
def is_capable(n, k, w, P):
track = 0
cnt = 0
i = 0
while cnt < k:
if i == n:
return i
if track + w[i] > P:
track = 0
cnt += 1
else:
track += w[i]
i += 1
return i
pass
# ??\?????¨
n, k = list(map(int, sys.stdin.readline().split()))
w = []
for i in range(n):
w.append(int(sys.stdin.readline().strip()))
'''
print(n,k)
print(w)
'''
# ????????¨
if k == 1:
ans = sum(w)
print(ans)
elif n == 1:
ans = w[0]
print(ans)
else:
max_p = sum(w)
min_p = math.ceil(max_p / k) - 1
# print(max_p, min_p)
# sys.exit(0)
bottom = min_p
top = max_p
while top - bottom > 1:
mid = (bottom + top) // 2
if is_capable(n, k, w, mid) == n:
top = mid
else:
bottom = mid
print(top) | p02270 |
from collections import deque
N=int(eval(input()))
A=[int(i) for i in input().split()]
A=[0]+A
for i in range(N):
A[i+1]+=A[i]
def dou(X):
n=len(X)
ma=len(X)-1
mi=0
while ma-mi>1:
mid = (ma + mi)//2
a=X[n-1]-X[mid]
b=X[mid-1]-X[0]
if a>b:
mi=mid
else:
ma=mid
#print(ma,mi)
return [X[mi]-X[0],X[n-1]-X[mi]]
num=10**14
K=A[:2]
L=deque(A[2:])
for i in range(2,N-1):
a=L.popleft()
L.appendleft(a)
K.append(a)
#print(K,L)
ans=[]
ans=ans+dou(K)+dou(L)
#print(ans)
#print(abs(max(ans)-min(ans)))
num=min(num,abs(max(ans)-min(ans)))
L.popleft()
print(num) | from collections import deque
N=int(eval(input()))
A=[int(i) for i in input().split()]
A=[0]+A
for i in range(N):
A[i+1]+=A[i]
def dou(i,j):
ma=j
mi=i
while ma-mi>1:
mid = (ma + mi)//2
a=A[j]-A[mid]
b=A[mid-1]-A[i]
if a>b:
mi=mid
else:
ma=mid
#print(ma,mi)
return [A[mi]-A[i],A[j]-A[mi]]
num=10**14
for i in range(2,N-1):
ans=[]
ans+=dou(0,i)
ans+=dou(i,N)
#print(ans)
t=max(ans)-min(ans)
num=min(num,t)
print(num) | p03312 |
from collections import deque
N=int(eval(input()))
A=[int(i) for i in input().split()]
A=[0]+A
for i in range(N):
A[i+1]+=A[i]
def dou(i,j):
ma=j
mi=i
while ma-mi>1:
mid = (ma + mi)//2
a=A[j]-A[mid]
b=A[mid-1]-A[i]
if a>b:
mi=mid
else:
ma=mid
#print(ma,mi)
return [A[mi]-A[i],A[j]-A[mi]]
num=10**14
for i in range(2,N-1):
ans=[]
ans+=dou(0,i)
ans+=dou(i,N)
#print(ans)
t=max(ans)-min(ans)
num=min(num,t)
print(num) | #from collections import deque
from bisect import bisect_left
N=int(eval(input()))
A=[int(i) for i in input().split()]
A=[0]+A
for i in range(N):
A[i+1]+=A[i]
num=10**14
for i in range(2,N-1):
ans=[]
x=(A[i]+A[0])/2
j=bisect_left(A,x)
#print(j,x)
if A[j]-x>x-A[j-1]:
j-=1
ans+=[A[j]-A[0],A[i]-A[j]]
y=(A[N]+A[i])/2
k=bisect_left(A,y)
#print(k,y)
if A[k]-y>y-A[k-1]:
k-=1
ans+=[A[N]-A[k],A[k]-A[i]]
#print(ans)
t=max(ans)-min(ans)
num=min(num,t)
print(num) | p03312 |
from itertools import accumulate
from bisect import bisect_right
N = int(eval(input()))
A = list(map(int, input().split()))
# 累積和を前計算
cumsum = list(accumulate(A))
cumsum.insert(0, 0)
#print(cumsum)
ans = float('inf')
# 真ん中を全探索
for i in range(2, N-1):
#print(A[:i], A[i:])
# 左の真ん中
LC = cumsum[i] / 2
LX = bisect_right(cumsum, LC)
#print(LX)
# 超えるべきか超えないべきか
if abs(cumsum[LX-1] - LC) < abs(cumsum[LX] - LC):
LX -= 1
# 右の真ん中
RC = (cumsum[N] + cumsum[i]) / 2
RX = bisect_right(cumsum, RC)
# 超えるべきか超えないべきか
if abs(cumsum[RX-1] - RC) < abs(cumsum[RX] - RC):
RX -= 1
P, Q, R, S = cumsum[LX], cumsum[i]-cumsum[LX], cumsum[RX]-cumsum[i], cumsum[N]-cumsum[RX]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| from itertools import accumulate
from bisect import bisect_right, bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
# 累積和を前計算
cumsum = list(accumulate(A))
cumsum.insert(0, 0) # out of index 対策
ans = float('inf')
# 真ん中を全探索
for i in range(2, N-1):
#print(cumsum[:i], cumsum[i:])
# 左の真ん中
LC = cumsum[i] / 2
LX = bisect_left(cumsum, LC)
#print(LX)
# 超えるべきか超えないべきか
if abs(cumsum[LX-1] - LC) < abs(cumsum[LX] - LC):
LX -= 1
# 右の真ん中
RC = (cumsum[N] + cumsum[i]) / 2
RX = bisect_left(cumsum, RC)
# 超えるべきか超えないべきか
if abs(cumsum[RX-1] - RC) < abs(cumsum[RX] - RC):
RX -= 1
P, Q, R, S = cumsum[LX], cumsum[i]-cumsum[LX], cumsum[RX]-cumsum[i], cumsum[N]-cumsum[RX]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| p03312 |
from bisect import bisect_left
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
cumsum = list(accumulate(A))
cumsum.insert(0, 0)
ans = float('inf')
# 真ん中区切り全探索
for m in range(2, N-1):
# 左
Lmid = cumsum[m] / 2
Lx = bisect_left(cumsum, Lmid)
# 境界チェック
if abs(Lmid - cumsum[Lx]) > abs(Lmid - cumsum[Lx-1]):
Lx -= 1
# 右
Rmid = (cumsum[m] + cumsum[N]) / 2
Rx = bisect_left(cumsum, Rmid)
# 境界チェック
if abs(Rmid - cumsum[Rx]) > abs(Rmid - cumsum[Rx-1]):
Rx -= 1
P, Q, R, S = cumsum[Lx], cumsum[m]-cumsum[Lx], cumsum[Rx]-cumsum[m], cumsum[N]-cumsum[Rx]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| from bisect import bisect_left
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
cumsum = list(accumulate(A))
cumsum.insert(0, 0)
ans = float('inf')
for m in range(2, N-1):
# 左
Lmid = cumsum[m] / 2
Lx = bisect_left(cumsum, Lmid)
if abs(Lmid-cumsum[Lx]) > abs(Lmid-cumsum[Lx-1]):
Lx -= 1
# 右
Rmid = (cumsum[m] + cumsum[N]) / 2
Rx = bisect_left(cumsum, Rmid)
if abs(Rmid-cumsum[Rx]) > abs(Rmid-cumsum[Rx-1]):
Rx -= 1
P, Q, R, S = cumsum[Lx], cumsum[m]-cumsum[Lx], cumsum[Rx]-cumsum[m], cumsum[N]-cumsum[Rx]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| p03312 |
from bisect import bisect_left as bl
from itertools import accumulate
INF = 10 ** 20
def get_score(acc, head, end):
sec_head = acc[head - 1]
sec_end = acc[end]
sec_sum = sec_end - sec_head
cut = bl(acc, sec_head + sec_sum // 2) - 1
score = INF
reta, retb = None, None
for i in range(cut - 2, cut + 3):
if head <= i < end:
a = acc[i] - sec_head
b = sec_end - acc[i]
if score > abs(a - b):
score = abs(a - b)
reta, retb = a, b
return (reta, retb)
n = int(eval(input()))
acc = [0]
acc += accumulate(list(map(int, input().split())))
ans = INF
for i in range(2, n - 1):
p, q = get_score(acc, 1, i)
r, s = get_score(acc, i + 1, n)
if not None in (p, q, r, s):
ans = min(ans, max(p, q, r, s) - min(p, q, r, s))
print(ans) | from bisect import bisect_left as bl
from itertools import accumulate
INF = 10 ** 20
def get_score(acc, head, end):
sec_head = acc[head - 1]
sec_end = acc[end]
sec_sum = sec_end - sec_head
cut = bl(acc, sec_head + sec_sum // 2) - 1
score = INF
reta, retb = None, None
for i in range(cut - 1, cut + 2):
if head <= i < end:
a = acc[i] - sec_head
b = sec_end - acc[i]
if score > abs(a - b):
score = abs(a - b)
reta, retb = a, b
return (reta, retb)
n = int(eval(input()))
acc = [0]
acc += accumulate(list(map(int, input().split())))
ans = INF
for i in range(2, n - 1):
p, q = get_score(acc, 1, i)
r, s = get_score(acc, i + 1, n)
if not None in (p, q, r, s):
ans = min(ans, max(p, q, r, s) - min(p, q, r, s))
print(ans) | p03312 |
n = int(eval(input()))
a = list(map(int, input().split()))
cumsum = [a[0]]
for i in range(1, n):
cumsum.append(cumsum[i-1] + a[i])
i, k = 0, 2
ans = 10**18
for j in range(1, n-2):
while i < j:
p = cumsum[i]
q = cumsum[j] - cumsum[i]
p_new = cumsum[i+1]
q_new = cumsum[j] - cumsum[i+1]
if abs(q_new - p_new) > abs(q - p):
break
else:
i += 1
while k < n-1:
r = cumsum[k] - cumsum[j]
s = cumsum[n-1] - cumsum[k]
r_new = cumsum[k+1] - cumsum[j]
s_new = cumsum[n-1] - cumsum[k+1]
if abs(s_new - r_new) > abs(s - r):
break
else:
k += 1
pqrs = [p, q, r, s]
ans = min(ans, abs(max(pqrs) - min(pqrs)))
# print(i, j, k, ans, pqrs)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
i, k = 0, 2
p, q, r, s = 0, a[0], a[1], sum(a[2:])
ans = sum(a)
for j in range(1, n-2):
q += a[j]
while abs((q-a[i]) - (p+a[i])) < abs(q - p):
p += a[i]
q -= a[i]
i += 1
r -= a[j]
while abs((s-a[k]) - (r+a[k])) < abs(s - r):
r += a[k]
s -= a[k]
k += 1
pqrs = [p, q, r, s]
ans = min(ans, abs(max(pqrs) - min(pqrs)))
# print(i, j, k, ans, pqrs)
print(ans) | p03312 |
n = int(eval(input()))
a = list(map(int, input().split()))
l, r = a[:2]
m = 1
b = [(l,r)]
for i in range(2, n-2):
r += a[i]
for j in range(m, i):
nl, nr = l+a[j], r-a[j]
if abs(l-r) < abs(nl-nr):
break
l, r = nl, nr
m += 1
b.append((l,r))
l, r = a[-2:]
m = n-2
c = [(l,r)]
for i in range(2, n-2)[::-1]:
l += a[i]
for j in range(i+1, m+1)[::-1]:
nl, nr = l-a[j], r+a[j]
if abs(l-r) < abs(nl-nr):
break
l, r = nl, nr
m -= 1
c.append((l,r))
r = 10**9
for i in range(n-3):
x = max(b[i]+c[-i-1])
y = min(b[i]+c[-i-1])
r = min(r, x-y)
print(r)
| n = int(eval(input()))
a = list(map(int, input().split()))
def f(a):
l, r = a[:2]
m = 1
b = [(l,r)]
for i in range(2, n-2):
r += a[i]
while m<i and abs(l-r)>abs(l-r+a[m]*2):
l, r = l+a[m], r-a[m]
m += 1
b.append((l,r))
return b
print((min(max(p,q,r,s)-min(p,q,r,s)
for ((p,q),(r,s)) in zip(f(a), f(a[::-1])[::-1])))) | p03312 |
N = int(eval(input()))
A = list(map(int,input().split()))
from bisect import bisect
# 区間の和を高速に求めたいので累積和
S = [0]*N
S[0] = A[0]
for i in range(1,N):
S[i] = S[i-1]+A[i]
Ans = 10**15
# 真ん中の分割位置を全探索
for i in range(2,N-1):
# 前半と後半に分離
A,B = S[:i],S[i:]
sumA,sumB = S[i-1],S[N-1]-S[i-1]
canA,canB = [],[]
# 前半部分,後半部分をそれぞれできるだけ均等になるように分割
ax = S[i-1]/2
ai = bisect(S,ax)
if abs(S[ai-1]-ax) < abs(S[ai]-ax):
ai -= 1
bx = (S[N-1]+S[i-1])/2
bi = bisect(S,bx)
if abs(S[bi-1]-bx) < abs(S[bi]-bx):
bi -= 1
x1,x2,x3,x4 = S[ai],S[i-1]-S[ai],S[bi]-S[i-1],S[N-1]-S[bi]
# 考慮した組み合わせで最小のものを記録
Ans = min(Ans,max(x1,x2,x3,x4)-min(x1,x2,x3,x4))
print(Ans) | N = int(eval(input()))
A = list(map(int,input().split()))
from bisect import bisect
# 区間の和を高速に求めたいので累積和
S = [0]*N
S[0] = A[0]
for i in range(1,N):
S[i] = S[i-1]+A[i]
Ans = 10**15
# 真ん中の分割位置を全探索
for i in range(2,N-1):
# 前半部分,後半部分をそれぞれできるだけ均等になるように分割
ax = S[i-1]/2
ai = bisect(S,ax)
if abs(S[ai-1]-ax) < abs(S[ai]-ax):
ai -= 1
bx = (S[N-1]+S[i-1])/2
bi = bisect(S,bx)
if abs(S[bi-1]-bx) < abs(S[bi]-bx):
bi -= 1
x1,x2,x3,x4 = S[ai],S[i-1]-S[ai],S[bi]-S[i-1],S[N-1]-S[bi]
# 考慮した組み合わせで最小のものを記録
Ans = min(Ans,max(x1,x2,x3,x4)-min(x1,x2,x3,x4))
print(Ans) | p03312 |
import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
S = [A[0]]
for i in range(1,N):
S.append(S[i-1]+A[i])
ans = 10**20
for i in range(2, N-1):
m = bisect.bisect(S[:i], S[:i][-1]//2)
if m == 0:
L = [S[:i][0], S[:i][-1]-S[:i][0]]
else:
L = [S[:i][m], S[:i][-1]-S[:i][m]]
L2 = [S[:i][m-1], S[:i][-1]-S[:i][m-1]]
if(abs(L[0]-L[1]) > abs(L2[0]-L2[1])): L = L2
m = bisect.bisect(S[i:], (S[i:][-1]+S[:i][-1])//2)
if m == 0:
R = [S[i:][0]-S[:i][-1], S[i:][-1]-S[i:][0]]
else:
R = [S[i:][m]-S[:i][-1], S[i:][-1]-S[i:][m]]
R2 = [S[i:][m-1]-S[:i][-1], S[i:][-1]-S[i:][m-1]]
if(abs(R[0]-R[1]) > abs(R2[0]-R2[1])): R = R2
#print(L, end="")
#print(R)
ans = min(ans, max(L[0],L[1],R[0],R[1]) - min(L[0],L[1],R[0],R[1]))
print(ans)
| import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
S = [A[0]]
for i in range(1,N):
S.append(S[i-1]+A[i])
ans = 1e18
for i in range(2, N-1):
# 左側 [0,i)
left_sum = S[i-1]
m = bisect.bisect(S, left_sum/2)
L = [S[m], left_sum-S[m]]
if m != 0:
L2 = [S[m-1], left_sum - S[m-1]]
if(abs(L[0]-L[1]) > abs(L2[0]-L2[1])): L = L2
# 右側 [i,N)
m = bisect.bisect(S, (S[-1]+left_sum)/2)
R = [S[m]-left_sum, S[-1]-S[m]]
if m != i:
R2 = [S[m-1]-left_sum, S[-1]-S[m-1]]
if(abs(R[0]-R[1]) > abs(R2[0]-R2[1])): R = R2
ans = min(ans, max(L[0],L[1],R[0],R[1]) - min(L[0],L[1],R[0],R[1]))
print(ans)
| p03312 |
from itertools import accumulate
from bisect import bisect_right
N = int(eval(input()))
As = list(map(int, input().split()))
accAs = [0] + list(accumulate(As))
# As[iFr]～As[iTo]の和を求める
def getSum(iFr, iTo):
return accAs[iTo+1] - accAs[iFr]
# As[iFr]～As[iTo]を前後半の総和の差が最小となるように分解する
def getDivision(iFr, iTo):
sumB = getSum(iFr, iTo)
iMid = bisect_right(accAs, accAs[iFr]+sumB/2, iFr+1, iTo+2) - 1
diff1, diff2 = float('inf'), float('inf')
if iMid != iFr:
sum1L = getSum(iFr, iMid-1)
sum1R = getSum(iMid, iTo)
diff1 = abs(sum1L - sum1R)
if iMid != iTo:
sum2L = getSum(iFr, iMid)
sum2R = getSum(iMid+1, iTo)
diff2 = abs(sum2L - sum2R)
return [sum1L, sum1R] if diff1 <= diff2 else [sum2L, sum2R]
# 真ん中の区切りを全通り試す
ans = float('inf')
for iMid in range(1, N-3+1):
sumD = []
sumD += getDivision(0, iMid)
sumD += getDivision(iMid+1, N-1)
ans = min(ans, max(sumD) - min(sumD))
print(ans)
| N = int(eval(input()))
As = list(map(int, input().split()))
ans = float('inf')
iB, iD = 1, 3
(P, Q, R), S = As[:3], sum(As[3:])
# 真ん中の区切りを全通り試す
for iC in range(2, N - 1):
while P < Q and As[iB] <= Q - P:
P += As[iB]
Q -= As[iB]
iB += 1
while R < S and As[iD] <= S - R:
R += As[iD]
S -= As[iD]
iD += 1
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
Q += As[iC]
R -= As[iC]
print(ans)
| p03312 |
from itertools import accumulate
from bisect import bisect_left
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
def helper(i,j):
m = (C[j]+C[i])/2
k = bisect_left(C, m, lo=i+1,hi=j-1)
if k > i+1:
_,a,b = min((abs(m-C[x]),C[x]-C[i],C[j]-C[x]) for x in (k-1,k))
else:
a,b = C[k]-C[i],C[j]-C[k]
return a,b
m = bisect_left(C,C[N]/2)
if m < 2:
m = 2
elif m > N-2:
m = N-2
L = helper(0,m)+helper(m,N)
best = max(L)-min(L)
i = m+1
while i < N-1 and abs(abs(C[N]-C[i])-abs(C[i])) < best*2:
L = helper(0,i)+helper(i,N)
best = min(best, max(L)-min(L))
i += 1
i = m-1
while i > 1 and abs(abs(C[N]-C[i])-abs(C[i])) < best*2:
L = helper(0,i)+helper(i,N)
best = min(best, max(L)-min(L))
i -= 1
print(best) | from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
def h(i,j):
ci,cj = C[i],C[j]
k = bisect(C, (ci+cj)//2, lo=i+1,hi=j)
_,a,b = min((abs(ci+cj-2*c),cj-c,c-ci) for c in (C[k-1],C[k]))
return a,b
def solve(x):
L = h(0,x)+h(x,N)
return max(L)-min(L)
print((min(solve(i) for i in range(2,N-1)))) | p03312 |
from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
S = C[N]
def solve(x):
cx = C[x]
k = bisect(C, cx//2, lo=1,hi=x)
_,a,b = min((abs(cx-2*c),cx-c,c) for c in (C[k-1],C[k]))
k = bisect(C, (S+cx)//2, lo=x+1,hi=N)
_,c,d = min((abs(cx+S-2*c),S-c,c-cx) for c in (C[k-1],C[k]))
L = (a,b,c,d)
return max(L)-min(L)
print((min(solve(i) for i in range(2,N-1)))) | from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
S = C[N]
def it():
k1 = 1
k2 = 3
for i in range(2,N-1):
ci = C[i]
k1 = bisect(C, ci//2, lo=k1,hi=i)
_,a,b = min((abs(ci-2*c),ci-c,c) for c in (C[k1-1],C[k1]))
k2 = bisect(C, (S+ci)//2, lo=k2,hi=N)
_,c,d = min((abs(ci+S-2*c),S-c,c-ci) for c in (C[k2-1],C[k2]))
yield max(a,b,c,d)-min(a,b,c,d)
print((min(it()))) | p03312 |
from collections import deque
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
n=II()
aa=LI()
p=aa[0]
q=aa[1]
j=1
dl=abs(p-q)
k=3
r=aa[2]
s=sum(aa[3:])
dr=abs(r-s)
while abs(r-s+aa[k]*2)<dr:
r+=aa[k]
s-=aa[k]
dr=abs(r-s)
k+=1
ans=max(p,q,r,s)-min(p,q,r,s)
for i in range(3,n-1):
q += aa[i - 1]
dl = abs(p - q)
while abs(p - q + aa[j] * 2) < dl:
p += aa[j]
q -= aa[j]
dl = abs(p - q)
j += 1
r -= aa[i - 1]
dr = abs(r - s)
while abs(r-s+aa[k]*2)<dr:
r+=aa[k]
s-=aa[k]
dr=abs(r-s)
k+=1
cur=max(p,q,r,s)-min(p,q,r,s)
if cur<ans:ans=cur
print(ans)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
dij=[(1,0),(0,1),(-1,0),(0,-1)]
def main():
n=II()
aa=LI()
pre=[0]*(n+1)
for i in range(n):pre[i+1]+=pre[i]+aa[i]
ll=[[0]*2 for _ in range(n)]
rr=[[0]*2 for _ in range(n)]
j=1
for i in range(2,n-1):
while j<i-1 and pre[i]-pre[j]*2>0:j+=1
if pre[i]-pre[j-1]*2<-pre[i]+pre[j]*2:j-=1
ll[i][0]=min(pre[i]-pre[j],pre[j])
ll[i][1]=max(pre[i]-pre[j],pre[j])
j=n-1
for i in range(n-2,1,-1):
while j>i+1 and pre[n]+pre[i]-pre[j]*2<0:j-=1
if -pre[n]-pre[i]+pre[j+1]*2<pre[n]+pre[i]-pre[j]*2:j+=1
rr[i][0]=min(pre[n]-pre[j],pre[j]-pre[i])
rr[i][1]=max(pre[n]-pre[j],pre[j]-pre[i])
#print(ll,rr)
ans=10**16
for i in range(2,n-1):
mn=min(ll[i][0],rr[i][0])
mx=max(ll[i][1],rr[i][1])
cur=mx-mn
if cur<ans:ans=cur
print(ans)
main()
| p03312 |
N = int(eval(input()))
A = [int(_) for _ in input().split()]
ans = []
for _ in range(2, N-1):
p = A[:_]
q = A[_:]
P = sum(p)
Q = sum(q)
p_sa = 10**15
q_sa = 10**15
for i in range(1,len(p)):
s = sum(p[:i])
sa = abs(P-s*2)
if sa < p_sa:
n = [s,P-s]
p_sa = sa
for i in range(1,len(q)):
s = sum(q[:i])
sa = abs(Q - s*2)
if sa < q_sa:
m = [s,Q-s]
q_sa = sa
ans.append(max(n+m)-min(n+m))
print((min(ans))) | N = int(eval(input()))
A = [int(_) for _ in input().split()]
ans = []
t = []
c = 0
for i in range(N):
c += A[i]
t.append(c)
l = 0
r = 0
for _ in range(1, N-1):
while t[_] > t[l]+t[l+1]:
l += 1
while t[-1]+t[_] > t[r]+t[r+1]:
r += 1
n = [t[l], t[_]-t[l], t[r]-t[_], t[-1]-t[r]]
ans.append(max(n)-min(n))
print((min(ans))) | p03312 |
# ARC100D
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
# import numpy as np
import bisect
n = int(eval(input()))
a = list(map(int, input().split()))
# a = np.array(list(map(int, input().split())))
ca = [None] * n #ca[i] = a0~aiの和
s = 0
for i,num in enumerate(a):
s += a[i]
ca[i] = s
# ca = a.cumsum()
def sub(l, start, end, init):
if len(l)==0:
return 0,0
elif end-start==1:
return 0,l[start]-init
target = (init + l[end-1])/2
i = bisect.bisect_right(l, target)
p1 = (l[i]-init, l[end-1]-l[i])
p2 = (l[i-1]-init, l[end-1]-l[i-1])
if abs(p1[0] - p1[1]) < abs(p2[0] - p2[1]):
return min(p1), max(p1)
else:
return min(p2), max(p2)
best = 10**15
for i in range(1,n):
p1 = sub(ca, 0, i, 0)
p2 = sub(ca, i, n, ca[i-1])
nn = max(p1[1]-p2[0], p2[1]-p1[0], p1[1]-p1[0], p2[1]-p2[0])
# print(p1,p2,nn)
best = min(best, nn)
print(best) | # ARC100D
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
n = int(eval(input()))
a = list(map(int, input().split()))
ca = [None] * n #ca[i] = a0~aiの和
s = 0
for i,num in enumerate(a):
s += a[i]
ca[i] = s
diff = [None] * n
s = 0
t = 1
v1 = 0 # a[:s]
v2 = a[0] # sum(a[s:t])
diff[t-1] = (v1,v2)
while t<n:
# print(t, v1-v2)
t += 1
v2 += a[t-1]
while v1<v2 and s<t:
if diff[t-1] is None or abs(v1-v2)<abs(diff[t-1][0] - diff[t-1][1]):
diff[t-1] = (v1,v2)
s += 1
v1 += a[s-1]
v2 -= a[s-1]
if diff[t-1] is None or abs(v1-v2)<abs(diff[t-1][0] - diff[t-1][1]):
diff[t-1] = (v1,v2)
if v1>v2 and s>=1:
v1 -= a[s-1]
v2 += a[s-1]
s -= 1
diff2 = [None] * n
s = n
t = n-1
v1 = 0 # sum(a[s:])
v2 = a[-1] # sum(a[t:s])
diff2[t] = (v1,v2)
while t>=1:
# print(t, v1, v2)
t -= 1
v2 += a[t]
while v1<v2 and s>t:
if diff2[t] is None or abs(v1-v2)<abs(diff2[t][0] - diff2[t][1]):
diff2[t] = (v1,v2)
s -= 1
v1 += a[s]
v2 -= a[s]
if diff2[t] is None or abs(v1-v2)<abs(diff2[t][0] - diff2[t][1]):
diff2[t] = (v1,v2)
if v1>v2 and s<=n-2:
v1 -= a[s]
v2 += a[s]
s += 1
print((min((max(diff[i][0], diff[i][1],diff2[i+1][0],diff2[i+1][1]) - min(diff[i][0], diff[i][1],diff2[i+1][0],diff2[i+1][1])) for i in range(n-1)))) | p03312 |
def main():
from itertools import accumulate, product
def binary_search(a, x, lo, hi):
while lo < hi:
mid = (lo + hi) // 2
if a[mid] < x:
lo = mid + 1
else:
hi = mid
return lo
n = int(eval(input()))
*a, = list(map(int, input().split()))
acc = (0,) + tuple(accumulate(a))
# [0,i), [i,j), [j,k), [k, n)
ret = acc[-1]
for j in range(2, n - 1):
left = acc[j]
right = acc[-1] - left
i = binary_search(acc, left // 2, 2, j + 2)
k = binary_search(acc, left + (right // 2), j + 2, n + 1)
li = i - 1, i
rk = k - 1, k
for i, k in product(li, rk):
if i <= 0 or k <= j:
continue
pqrs = acc[i], left - acc[i], acc[k] - left, acc[-1] - acc[k]
ret = min(
ret,
max(pqrs) - min(pqrs)
)
print(ret)
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
*a, = list(map(int, input().split()))
# [0,i), [i,j), [j,k), [k, n)
tot = sum(a)
ret = tot
i, k = 1, 3
p, q, r, s = a[0], a[1], a[2], tot - sum(a[:3])
for j in range(2, n - 1):
while (i + 1 < j) and (abs(p - q + a[i] * 2) < abs(p - q)):
p += a[i]
q -= a[i]
i += 1
while (k + 1 < n) and (abs(r - s + a[k] * 2) < abs(r - s)):
r += a[k]
s -= a[k]
k += 1
ret = min(ret, max(p, q, r, s) - min(p, q, r, s))
q += a[j]
r -= a[j]
print(ret)
if __name__ == '__main__':
main()
| p03312 |
# coding: utf-8
import sys
sys.setrecursionlimit(10 ** 7)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
def min_max(arr):
"""リストの中を二つに分けて、総和の小さい方と大きい方を返す"""
left = 0; right = len(arr)-1
l_total = arr[left]
r_total = arr[right]
while left + 1 < right:
if l_total <= r_total:
left += 1
l_total += arr[left]
else:
right -= 1
r_total += arr[right]
mi, ma = min(l_total, r_total), max(l_total, r_total)
return mi, ma
answer = 10 ** 15
mid = N // 2
used = set([0, 1, N-1])
def F(l, mid, r):
global answer, used
used.add(mid)
l_min, l_max = min_max(A[:mid])
r_min, r_max = min_max(A[mid:])
temp = max(l_max, r_max) - min(l_min, r_min)
if temp < answer:
answer = temp
if l_min <= r_min:
m = (mid+r)//2
if m not in used:
F(mid, m, r)
else:
m = (mid+l)//2
if m not in used:
F(l, m, mid)
if l_max >= r_max:
m = (mid+l)//2
if m not in used:
F(l, m, mid)
else:
m = (mid+r)//2
if m not in used:
F(mid, m, r)
F(0, mid, N-1)
print(answer)
# 08 | # coding: utf-8
import sys
from itertools import accumulate
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
Acum = list(accumulate(A))
l_cut = [None] * N # 左のリストで2つに切り分けるindex
l_cut[1] = 0
l = A[0]; r = A[1]
for i in range(2, N):
r += A[i]
diff = abs(r-l)
index = l_cut[i-1]
while index < i - 1:
temp = abs(l + A[index+1] - (r - A[index+1]))
if temp < diff:
index += 1
l += A[index]
r -= A[index]
diff = temp
else:
break
l_cut[i] = index
r_cut = [None] * N
r_cut[-2] = N-2
l = A[-2]; r = A[-1]
for i in range(N-3, 0, -1):
l += A[i]
diff = abs(r-l)
index = r_cut[i+1]
while index > i:
temp = abs(r + A[index] - (l - A[index]))
if temp < diff:
index -= 1
r += A[index+1]
l -= A[index+1]
diff = temp
else:
break
r_cut[i] = index
answer = 10 ** 17
for i in range(1, N-2):
a = Acum[l_cut[i]]
b = Acum[i] - a
c = Acum[r_cut[i+1]] - Acum[i]
d = Acum[-1] - (a + b + c)
temp = max(a, b, c, d) - min(a, b, c, d)
if temp < answer:
answer = temp
print(answer)
# 27r | p03312 |
def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
n=i1()
a=i2()
c=[0 for i in range(n)]
b=sum(a)
for i in range(n):
if i: c[i]+=c[i-1]
c[i]+=a[i]
f=float("inf")
import bisect
e=[]
b=a[0]
d=c[n-1]-c[0]
for i in range(1,n-2):
b+=a[i]
d-=a[i]
x=bisect.bisect_left(c[:i+1],b/2)
if abs(c[i]-2*c[x])>abs(c[i]-2*c[x-1]) and x>0:
e.append(c[i]-c[x-1])
e.append(c[x-1])
else:
e.append(c[i]-c[x])
e.append(c[x])
y=bisect.bisect_left(c[i+1:],d/2+c[i])+i+1
if abs(c[n-1]-c[y]-(c[y]-c[i]))>abs(c[n-1]-c[y-1]-(c[y-1]-c[i])) and y>0:
e.append(c[n-1]-c[y-1])
e.append(c[y-1]-c[i])
else:
e.append(c[n-1]-c[y])
e.append(c[y]-c[i])
f=min(f,max(e)-min(e))
e=[]
print(f) | def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
n=i1()
a=i2()
c=[0 for i in range(n)]
for i in range(n):
if i: c[i]+=c[i-1]
c[i]+=a[i]
l=0
r=2
f=float("inf")
for i in range(1,n-1):
while abs(c[l]-(c[i]-c[l]))>abs(c[l+1]-(c[i]-c[l+1])):
l+=1
while abs(c[r]-c[i]-(c[n-1]-c[r]))>abs(c[r+1]-c[i]-(c[n-1]-c[r+1])):
r+=1
e=[c[l],c[i]-c[l],c[r]-c[i],c[n-1]-c[r]]
f=min(f,max(e)-min(e))
print(f) | p03312 |
n=int(eval(input()))
s=list(map(int,input().split()))
a=[0]
for _ in range(n):
a.append(sum(s[:_+1]))
ans=10**9
f=1
g=3
for i in range(2,n-1):
while f < i and abs(a[f]-(a[i]-a[f])) > abs(a[f+1]-(a[i]-a[f+1])):
f+=1
while g < n and abs(a[g]-a[i]-(a[n]-a[g])) > abs(a[g+1]-a[i]-(a[n]-a[g+1])):
g+=1
ls=[a[f],a[i]-a[f],a[g]-a[i],a[n]-a[g]]
ans=min(ans,max(ls)-min(ls))
print(ans) | n=int(eval(input()))
s=list(map(int,input().split()))
a=[0]
c=0
for si in s:
c+=si
a.append(c)
ans=[]
f=1
g=3
for i in range(2,n-1):
while abs(a[f]-(a[i]-a[f])) > abs(a[f+1]-(a[i]-a[f+1])):
f+=1
while abs(a[g]-a[i]-(a[n]-a[g])) > abs(a[g+1]-a[i]-(a[n]-a[g+1])):
g+=1
ls=[a[f],a[i]-a[f],a[g]-a[i],a[n]-a[g]]
ans.append(max(ls)-min(ls))
print((min(ans)))
| p03312 |
from bisect import bisect
from time import time
st_time = time()
N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ans = cums[-1] * 999
c = bisect(cums, cums[-1]//2)
d = 1
while time() - st_time < 1.94:
if abs(d) >= N: break
if 2 <= c <= N-2:
b1 = bisect(cums[:c], cums[c]//2)
b2 = bisect(cums[c:], (cums[c]+cums[-1])//2) + c
pq_cands = []
for i in (b1,b1-1):
if not 0 < i < c: continue
p = cums[i]
q = cums[c] - cums[i]
pq_cands.append((p,q))
rs_cands = []
for i in (b2,b2-1):
if not c < i < N: continue
r = cums[i] - cums[c]
s = cums[-1] - cums[i]
rs_cands.append((r,s))
for p,q in pq_cands:
for r,s in rs_cands:
mn = min(p,q,r,s)
mx = max(p,q,r,s)
ans = min(ans, mx-mn)
c += d
d = (abs(d)+1) * [1,-1][d%2]
print(ans) | from bisect import bisect
from time import time
st_time = time()
N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ans = cums[-1] * 999
c = bisect(cums, cums[-1]//2)
d = 1
while time() - st_time < 1.9:
if abs(d) >= N: break
if 2 <= c <= N-2:
b1 = bisect(cums[:c], cums[c]//2)
b2 = bisect(cums[c:], (cums[c]+cums[-1])//2) + c
pq_cands = []
for i in (b1,b1-1):
if not 0 < i < c: continue
p = cums[i]
q = cums[c] - cums[i]
pq_cands.append((p,q))
rs_cands = []
for i in (b2,b2-1):
if not c < i < N: continue
r = cums[i] - cums[c]
s = cums[-1] - cums[i]
rs_cands.append((r,s))
for p,q in pq_cands:
for r,s in rs_cands:
mn = min(p,q,r,s)
mx = max(p,q,r,s)
ans = min(ans, mx-mn)
c += d
d = (abs(d)+1) * [1,-1][d%2]
print(ans) | p03312 |
from bisect import bisect
from time import time
st_time = time()
N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ans = cums[-1] * 999
c = bisect(cums, cums[-1]//2)
d = 1
while time() - st_time < 1.9:
if abs(d) >= N: break
if 2 <= c <= N-2:
b1 = bisect(cums[:c], cums[c]//2)
b2 = bisect(cums[c:], (cums[c]+cums[-1])//2) + c
pq_cands = []
for i in (b1,b1-1):
if not 0 < i < c: continue
p = cums[i]
q = cums[c] - cums[i]
pq_cands.append((p,q))
rs_cands = []
for i in (b2,b2-1):
if not c < i < N: continue
r = cums[i] - cums[c]
s = cums[-1] - cums[i]
rs_cands.append((r,s))
for p,q in pq_cands:
for r,s in rs_cands:
mn = min(p,q,r,s)
mx = max(p,q,r,s)
ans = min(ans, mx-mn)
c += d
d = (abs(d)+1) * [1,-1][d%2]
print(ans) | from bisect import bisect
from time import time
st_time = time()
N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ans = cums[-1] * 999
c = bisect(cums, cums[-1]//2)
d = 1
while time() - st_time < 1.85:
if abs(d) >= N: break
if 2 <= c <= N-2:
b1 = bisect(cums[:c], cums[c]//2)
b2 = bisect(cums[c:], (cums[c]+cums[-1])//2) + c
pq_cands = []
for i in (b1,b1-1):
if not 0 < i < c: continue
p = cums[i]
q = cums[c] - cums[i]
pq_cands.append((p,q))
rs_cands = []
for i in (b2,b2-1):
if not c < i < N: continue
r = cums[i] - cums[c]
s = cums[-1] - cums[i]
rs_cands.append((r,s))
for p,q in pq_cands:
for r,s in rs_cands:
mn = min(p,q,r,s)
mx = max(p,q,r,s)
ans = min(ans, mx-mn)
c += d
d = (abs(d)+1) * [1,-1][d%2]
print(ans) | p03312 |
from bisect import bisect
from time import time
st_time = time()
N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ans = cums[-1] * 999
c = bisect(cums, cums[-1]//2)
d = 1
while time() - st_time < 1.85:
if abs(d) >= N: break
if 2 <= c <= N-2:
b1 = bisect(cums[:c], cums[c]//2)
b2 = bisect(cums[c:], (cums[c]+cums[-1])//2) + c
pq_cands = []
for i in (b1,b1-1):
if not 0 < i < c: continue
p = cums[i]
q = cums[c] - cums[i]
pq_cands.append((p,q))
rs_cands = []
for i in (b2,b2-1):
if not c < i < N: continue
r = cums[i] - cums[c]
s = cums[-1] - cums[i]
rs_cands.append((r,s))
for p,q in pq_cands:
for r,s in rs_cands:
mn = min(p,q,r,s)
mx = max(p,q,r,s)
ans = min(ans, mx-mn)
c += d
d = (abs(d)+1) * [1,-1][d%2]
print(ans) | N = int(eval(input()))
src = list(map(int,input().split()))
cums = [0]
for a in src:
cums.append(cums[-1] + a)
ps = [None] * (N+1)
qs = [None] * (N+1)
rs = [None] * (N+1)
ss = [None] * (N+1)
l = 1
for r in range(2,N-1):
p1 = cums[l]
q1 = cums[r] - cums[l]
d1 = abs(p1-q1)
while l < r:
p2 = cums[l+1]
q2 = cums[r] - cums[l+1]
d2 = abs(p2-q2)
if d2 > d1: break
l += 1
p1,q1,d1 = p2,q2,d2
ps[r] = p1
qs[r] = q1
r = N-1
for l in range(N-2,1,-1):
r1 = cums[r] - cums[l]
s1 = cums[N] - cums[r]
d1 = abs(r1-s1)
while l < r:
r2 = cums[r-1] - cums[l]
s2 = cums[N] - cums[r-1]
d2 = abs(r2-s2)
if d2 > d1: break
r -= 1
r1,s1,d1 = r2,s2,d2
rs[l] = r1
ss[l] = s1
ans = cums[-1] * 999
for p,q,r,s in zip(ps,qs,rs,ss):
if p is None: continue
tmp = max(p,q,r,s) - min(p,q,r,s)
ans = min(ans, tmp)
print(ans) | p03312 |
# arc 100 D
def ruiseki(n,array):
res = [0]*(n+1)
for i in range(n):
res[i+1] = res[i] + array[i]
return res
n = int(eval(input()))
A = list(map(int,input().split()))
sa = ruiseki(n,A)
from bisect import bisect_right
ans = 10**15
for i in range(1,n-2):
left = sa[i+1]
right = sa[-1] - sa[i+1]
lsplit = min(bisect_right(sa[:i+1],left//2) - 2,i-1)
rsplit = min(bisect_right(sa[i+1:],right//2 + left) + i-1,n-2)
lleft = [(sa[lsplit + 1],sa[i+1] - sa[lsplit + 1]),(sa[lsplit + 2],sa[i+1] - sa[lsplit + 2])]
rright = [(sa[rsplit+1] - sa[i+1],sa[-1] - sa[rsplit+1]),(sa[rsplit+2] - sa[i+1],sa[-1] - sa[rsplit+2])]
for s,t in [(0,0),(0,1),(1,0),(1,1)]:
l = lleft[s]
r = rright[t]
m = min(l+r)
M = max(l+r)
ans = min(ans,M-m)
print(ans)
| # arc 100 D
def ruiseki(n,array):
res = [0]*(n)
for i in range(n):
res[i] = res[i-1] + array[i]
return res
n = int(eval(input()))
A = list(map(int,input().split()))
sa = ruiseki(n,A)
ans = 10**15
left_c = 0
right_c = 2
for center in range(1,n-1):
while left_c+1 < center:
if abs(sa[center]-2*sa[left_c]) > abs(sa[center]-2*sa[left_c+1]):
left_c+=1
else:
break
right_c = max(right_c, center+1)
while right_c+1 < n-1:
if abs(sa[-1] + sa[center] - 2*sa[right_c]) > abs(sa[-1] + sa[center] - 2*sa[right_c+1]):
right_c+=1
else:
break
x = max(sa[left_c], sa[center]-sa[left_c], sa[right_c]-sa[center], sa[-1]-sa[right_c])
y = min(sa[left_c], sa[center]-sa[left_c], sa[right_c]-sa[center], sa[-1]-sa[right_c])
ans = min(ans, x-y)
print(ans)
| p03312 |
import random
from itertools import accumulate
N = int(eval(input()))
As = [int(i) for i in input().split(' ')]
#N = pow(10, 4)
#As = [random.randint(0,1000) for r in range(N)]
As = list(accumulate(As))
def bsearch(L, l, r, ls, rs):
if r - l == 0:
l_temp = L[l-1] if l!=0 else 0
lsum = l_temp - ls
return [max(lsum, rs - L[l]), min(lsum, rs - L[l]) + L[l] - l_temp]
n = int((r-l)/2)
lsum = L[l+n] - ls
rsum = rs - L[l+n]
if lsum > rsum:
return bsearch(L, l, l+n, ls, rs)
else:
return bsearch(L, l+n+1, r, ls, rs)
for i in range(N-3):
cs = bsearch(As, 0, i+1, 0, As[i+1]) + bsearch(As ,i+2, N-1, As[i+1], As[-1])
if i == 0:
result = max(cs) - min(cs)
else:
if max(cs) - min(cs) < result:
result = max(cs) - min(cs)
print(result)
|
def bsearch(mn, mx, func):
#func(i)=False を満たす最大のi
idx = (mx + mn)//2
while mx-mn>1:
if func(idx):
idx, mx = (idx + mn)//2, idx
continue
idx, mn = (idx + mx)//2, idx
return idx
N, = list(map(int, input().split()))
A = list(map(int, input().split()))
X = [0]*(N+2)
for i in range(N):
X[i+1] = X[i] + A[i]
R = 10**18
for i in range(2, N-1):
# X0, X1, X2 .. Xi
# Xj Xj+1 (1<= j <= i-1)
idx1 = bsearch(1, i-1, lambda j:X[i]//2 < X[j])
idx2 = bsearch(i+1, N, lambda j:(X[N]-X[i])//2 < (X[j]-X[i]))
# print(X[idx1], X[i]-X[idx1], X[idx2]-X[i], X[N]-X[idx2])
if idx1+1 <= i-1:
if abs(2*X[idx1]-X[i]) > abs(2*X[idx1+1]-X[i]):
idx1+=1
# print(1,i,idx2)
if idx2+1 <= N-1:
if abs(2*X[idx2]-X[i]-X[N]) > abs(2*X[idx2+1]-X[i]-X[N]):
idx2+=1
mx = max([X[idx1], X[i]-X[idx1], X[idx2]-X[i], X[N]-X[idx2]])
mn = min([X[idx1], X[i]-X[idx1], X[idx2]-X[i], X[N]-X[idx2]])
# print(X[i]-X[idx1], X[idx1], X[idx2]-X[i])
# print(idx1, i, idx2)
# print(mx-mn)
R = min(R, mx-mn)
print(R)
| p03312 |
def inpl(): return [int(i) for i in input().split()]
N, K = inpl()
H = {0: 0}
for i in range(N):
a, b= inpl()
for ia, ib in list(H.copy().items()):
if ia | a <= K or (ia == 0 and a <= K):
H[ia|a] = max(H.get(ia|a, 0), ib+b)
print((max(H.values()))) | import sys
N, K = list(map(int, input().split()))
candi = []
p = 0
for i in range(30, -1, -1):
if 2**i & K == 0:
p += 2**i
continue
else:
candi.append(p + 2**i)
candi.append(p)
AB = [tuple(map(int, input().split())) for _ in range(N)]
ans = 0
for c in candi:
cans = 0
for a, b in AB:
if a & c:
continue
cans += b
ans = max(ans, cans)
print(ans) | p03584 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,k=list(map(int,input().split()))
k+=1
AB=[tuple(map(int,input().split())) for _ in range(n)]
dp=[0]*35 # dp[d]: less than が確定するのが d 桁目のときの最大値
# dp[d] の状態のものが a を買えるのは、d 以上の桁については ad<=kd かつ、
# d 桁目については ad<kd となるもののみ
for a,b in AB:
ndp=dp[:]
for d in range(34,-1,-1):
kd=(k>>d)&1
ad=(a>>d)&1
if(ad>kd): break
if(ad<kd):
ndp[d]=dp[d]+b
dp=ndp
print((max(dp)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,k=list(map(int,input().split()))
k+=1
AB=[tuple(map(int,input().split())) for _ in range(n)]
dp=[0]*35 # dp[d]: less than が確定するのが d 桁目のときの最大値
# dp[d] の状態のものが a を買えるのは、d 以上の桁については ad<=kd かつ、
# d 桁目については ad<kd となるもののみ
for a,b in AB:
for d in range(34,-1,-1):
kd=(k>>d)&1
ad=(a>>d)&1
if(ad>kd): break
if(ad<kd):
dp[d]=dp[d]+b
print((max(dp)))
resolve() | p03584 |
N,K,*X = list(map(int, open(0).read().split()))
S = bin(K)[2:]
L = len(S)
one = set()
ls = [(a,b) for a,b in zip(*[iter(X)]*2) if a<=K]
kls = [K]
ans = 0
for i in range(L):
if S[i]=='1':
m = int(S[:i]+'0'+'1'*(L-i-1),2)
kls.append(m)
for k in kls:
m = 0
for a,b in ls:
if k==k|a:
m += b
ans = max(ans,m)
print(ans) | N,K,*X = list(map(int,open(0).read().split()))
S = bin(K)[2:]
L = len(S)
ls = [(a,b) for a,b in zip(*[iter(X)]*2)]
s = '0'
ans = 0
for i,c in enumerate(S):
if c=='0':
s += c
continue
j = L-i
m = (1<<(j-1))-1
n = int(s,2)<<j
x = m|n
v = 0
for a,b in ls:
if x==x|a:
v += b
ans = max(v,ans)
s += c
v = 0
for a,b in ls:
if K==K|a:
v += b
ans = max(ans,v)
print(ans)
| p03584 |
import sys
input=sys.stdin.readline
N,K=list(map(int,input().split()))
integer=[]
for i in range(N):
a,b=list(map(int,input().split()))
integer.append([a,b])
bit=[]
for i in range(0,30):
if K>>i &1==1:
bit.append(i)
ans=0
for j in range(N):
test=0
for j in range(N):
a,b=integer[j]
if a|K==K:
test+=b
ans=max(ans,test)
for i in bit:
check=(K>>i)-1
test=0
for j in range(N):
a,b=integer[j]
if a>>i|check==check:
test+=b
ans=max(ans,test)
print(ans) | import sys
input=sys.stdin.readline
N,K=list(map(int,input().split()))
integer=[]
for i in range(N):
a,b=list(map(int,input().split()))
integer.append([a,b])
bit=[]
for i in range(0,30):
if K>>i &1==1:
bit.append(i)
ans=0
for j in range(N):
a,b=integer[j]
if a|K==K:
ans+=b
for i in bit:
check=(K>>i)-1
test=0
for j in range(N):
a,b=integer[j]
if a>>i|check==check:
test+=b
ans=max(ans,test)
print(ans)
| p03584 |
n,k = list(map(int, input().split()))
ans = 0
abl = []
for _ in range(n):
a,b = list(map(int, input().split()))
abl.append((a,b))
max_bit = 0
for i in range(31):
if k < pow(2,i):
max_bit = i
break
k_bits = [-1]*(max_bit)
for i in range(max_bit-1,-1,-1):
if k&(1<<i) > 0:
k_bits[i] = 1
else:
k_bits[i] = 0
# print(k_bits)
k_bits = k_bits[::-1]
bits_cands = []
bits_cands.append(k_bits[::-1])
for i in range(max_bit):
curr_row = []
for j in range(0,i):
curr_row.append(k_bits[j])
if k_bits[i] == 1:
curr_row.append(0)
curr_row = curr_row + [1]*(max_bit-1-i)
else:
for j in range(i,max_bit):
curr_row.append(k_bits[j])
bits_cands.append(curr_row[::-1])
# print(bits_cands)
ans = 0
for bits in bits_cands:
val = 0
for a,b in abl:
if a > k: continue
for i in range(max_bit):
if a&(1<<i) > 0 and bits[i] == 0:
break
else:
val += b
ans = max(ans,val)
print(ans)
# bits_cands = []
# print(max_bit)
# curr = [1]
# for i in range(max_bit-1,-1,-1):
# if k%(1<<i) == 0:
# curr.append(0)
# row = curr + [] | n,k = list(map(int, input().split()))
ans = 0
abl = [ tuple(map(int, input().split())) for _ in range(n) ]
kset = set()
kset.add(k)
for i in range(30):
if k&(1<<i) == 0: continue
v = 0
for j in range(i):
v += pow(2,j)
for j in range(i+1,30):
if k&(1<<j) > 0:
v += pow(2,j)
kset.add(v)
kl = list(kset)
ans = 0
for ki in kl:
v = 0
for a,b in abl:
if a > k: continue
for i in range(30):
if a&(1<<i) > 0 and ki&(1<<i) == 0:
break
else:
v += b
ans = max(ans, v)
print(ans)
| p03584 |
from collections import defaultdict
N, K = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N)]
visited = defaultdict(lambda : False)
L = set()
def dfs(x) :
if visited[x] :
return
visited[x] = True
for i in range(30) :
if x & (1 << i) == 0 :
continue
y = x ^ (1 << i)
if y <= K :
L.add(y)
else :
dfs(y)
dfs((1 << (len(bin(K)) - 2)) - 1)
L.add(K)
ret = 0
for mask in L :
s = 0
for A, B in AB :
if A & ~mask == 0 :
s += B
ret = max(ret, s)
print(ret) | N, K = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N)]
ret = 0
for A, B in AB :
if A & ~K == 0 :
ret += B
for i in range(30) :
if K & (1 << i) == 0 :
continue
k = K
k ^= 1 << i
k |= (1 << i) - 1
s = 0
for A, B in AB :
if A & ~k == 0 :
s += B
ret = max(ret, s)
print(ret) | p03584 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import math
import copy
N, K = list(map(int, sys.stdin.readline().rstrip().split()))
data = []
for _ in range(N):
A, B = list(map(int, sys.stdin.readline().rstrip().split()))
# print(A)
# print(bin(A)[2:])
data.append([list(reversed(bin(A)[2:])), B])
ans = 0
def lower(x, y):
if(len(x) > len(y)):
return False
for xx, yy in zip(x, y):
if (xx == "1" and yy == "0"):
return False
else:
return True
Nstr = list(reversed(bin(K)[2:]))
subNstrs = [Nstr]
for i in range(len(Nstr)):
if Nstr[i] == "0":
continue
subNstr = copy.deepcopy(Nstr)
subNstr[i] = "0"
for j in range(i):
subNstr[j] = "1"
subNstrs.append(subNstr)
for subNstr in subNstrs:
subans = 0
for A, B in data:
# print(A, subNstr, lower(A, subNstr))
if(lower(A, subNstr)):
subans += B
# print(subNstr, subans)
ans = max(subans, ans)
print(ans)
exit(0)
| #!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import math
import copy
N, K = list(map(int, sys.stdin.readline().rstrip().split()))
data = []
for _ in range(N):
A, B = list(map(int, sys.stdin.readline().rstrip().split()))
data.append([A, B])
ans = 0
def lower(x, y):
if(x > y):
return False
# print(bin(x), bin(y), bin(x|y), bin((x | y) ^ y))
if((x | y) ^ y) == 0:
return True
else:
return False
Nstr = list(reversed(bin(K)[2:]))
subNs = [K]
for i in range(len(Nstr)):
if Nstr[i] == "0":
continue
subNstr = copy.deepcopy(Nstr)
subNstr[i] = "0"
for j in range(i):
subNstr[j] = "1"
realstr = ""
for s in reversed(subNstr):
realstr += s
subNs.append(int(realstr, 2))
for subNstr in subNs:
subans = 0
for A, B in data:
# print(A, subNstr, lower(A, subNstr))
if(lower(A, subNstr)):
subans += B
# print(subNstr, subans)
ans = max(subans, ans)
print(ans)
exit(0)
| p03584 |
def issubset(a,b):
#a<<bならtrue
x=bin(a)[2:]
y=bin(b)[2:]
if a>b:
return False
for i in range(1,len(x)+1):
if (x[-i],y[-i])==("1","0"):
return False
return True
N,K=list(map(int,input().split()))
A=[0 for i in range(N)]
B=[0 for i in range(N)]
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
Kl=[K]
Ks=bin(K)[2:]
for i,c in enumerate(Ks):
if c=="1":
Kl.append(int(Ks[:i]+"0"+"1"*(len(Ks)-i-1),2))
ans=0
for k in Kl:
tmp=0
for i in range(N):
if issubset(A[i],k):
tmp+=B[i]
ans=max(tmp,ans)
print(ans)
| def issubset(x,y):
#a<<bならtrue
if len(x)>len(y):
return False
for i in range(1,len(x)+1):
if (x[-i],y[-i])==("1","0"):
return False
return True
N,K=list(map(int,input().split()))
A=[0 for i in range(N)]
B=[0 for i in range(N)]
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
A[i]=bin(A[i])[2:]
Ks=bin(K)[2:]
Kl=[Ks]
for i,c in enumerate(Ks):
if c=="1":
Kl.append(Ks[:i]+"0"+"1"*(len(Ks)-i-1))
ans=0
for k in Kl:
tmp=0
for i in range(N):
if issubset(A[i],k):
tmp+=B[i]
ans=max(tmp,ans)
print(ans)
| p03584 |
import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,k=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ans=0
ab.sort()
m=bin(k)
# print(m)
klst=[m]
for i in range(2,len(m)):
if m[i]=="1":
klst.append(m[:i]+"0"+"1"*(len(m)-i-1))
# print(klst)
for i in klst:
tmp=0
for j in range(n):
a,b=ab[j]
m=bin(a)
if int(i,0)>=a:
for l in range(min(len(m),len(i))):
if i[-1-l]=="0" and m[-1-l]=="1":
break
else:
tmp+=b
ans=max(ans,tmp)
print(ans) | import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,k=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
ans=0
ab.sort()
m=bin(k)
# print(m)
klst=[m]
for i in range(2,len(m)):
if m[i]=="1":
klst.append(m[:i]+"0"+"1"*(len(m)-i-1))
# print(klst)
for i in klst:
tmp=0
for j in range(n):
a,b=ab[j]
if a|int(i,0)==int(i,0):
tmp+=b
ans=max(ans,tmp)
print(ans) | p03584 |
n,k=list(map(int,input().split()))
ab=[list(map(int,input(). split())) for _ in range(n)]
bk=list(bin(k)[2:])
if '0' not in bk:
t=k
ans=0
for a,b in ab:
if a<=t:ans+=b
print(ans)
else:
ks=[k]
for i in range(len(bk)):
if bk[i]=='1':
if i==0:
ks.append(int('1'*(len(bk)-1),2))
else:
ks.append(int(''.join(bk[:i])+'0'+'1'*(len(bk)-i-1),2))
ans=[0]*len(ks)
for a,b in ab:
for i in range(len(ks)):
if a&ks[i]==a:ans[i]+=b
print((max(ans))) | def main(n,k,ab):
ks=[k]
m=len(bin(k))-2
# kはm桁
kbin=bin(k)[2:]
now=0
for i in range(m):
if kbin[i]=='1' and i<m-1:
ks.append(now+pow(2,m-i-1)-1)
now+=int(kbin[i])*pow(2,m-i-1)
ans=0
for x in ks:
tmp=0
for a,b in ab:
if a|x==x:tmp+=b
ans=max(ans,tmp)
print(ans)
n,k=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(n)]
main(n,k,ab) | p03584 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 110101以下の数は、以下のいずれかである
#
# 110101
# 110100 (1を一つ選んで0にする、それ以下の桁はなんでもよいので?とする)
# 1100??
# 10????
# 0?????
#
# 上の各パターンについて条件を満たすものをそれぞれ探し、maxをとる
# 各パターンでは、0になるべき桁が必ず0になるようにする
#
# 実装上は、?をすべて1で置換。orをとっても以下の数値を超えないようにする
#
# 110101
# 110011
# 101111
# 011111
#
import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import re
import string
N, K = list(map(int, input().split()))
A = []
B = []
for n in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ret = 0
# orをとって 110101 以下になるもののみretに足す
for n in range(N):
if K | A[n] == K:
ret += B[n]
# Kの下位ビットから順に見ていき、もし1があれば、その桁を0にして、その桁より下位をすべて1にする
for n in range(31):
# n番目の桁が0なら、1にする
if (K >> n) & 1 == 0:
K |= (1 << n)
else:
# n番目の桁が1なら、0にする
K ^= (1 << n)
local_ret = 0
for m in range(N):
if K | A[m] == K:
local_ret += B[m]
ret = max(ret, local_ret)
# また1に戻す
K |= (1 << n)
print(ret)
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 動画解説を見る
#
# 110101以下の数は、以下のいずれかである
#
# 110101
# 110100 (1を一つ選んで0にする、それ以下の桁はなんでもよいので?とする)
# 1100??
# 10????
# 0?????
#
# 上の各パターンについて条件を満たすものをそれぞれ探し、maxをとる
# 各パターンでは、0になるべき桁が必ず0になるようにする
#
# 実装上は、?をすべて1で置換。orをとった結果、0の箇所に1が来ないようにする
#
# 110101
# 110011
# 101111
# 011111
import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import re
import string
N, K = list(map(int, input().split()))
A = []
B = []
for n in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ret = 0
# orをとって 110101 以下になるもののみretに足す
for n in range(N):
if K | A[n] == K:
ret += B[n]
# Kの下位ビットから順に見ていき、もし1があれば、その桁を0にして、その桁より下位をすべて1にする
for i in range(31):
# n番目の桁が0なら、1にする
if (K >> i) & 1 == 0:
K |= (1 << i)
else:
# n番目の桁が1なら、0にする
K ^= (1 << i)
local_ret = 0
for n in range(N):
if K | A[n] == K:
local_ret += B[n]
ret = max(ret, local_ret)
# また1に戻す
K |= (1 << i)
print(ret)
| p03584 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.