input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
x, t = list(map(int, input().split()))
print((max(0, x - t)))
| x, t = list(map(int, input().split()))
print((max(x - t, 0)))
| p03609 |
x,t=list(map(int,input().split()))
print((0 if x<=t else x-t)) | x,t=list(map(int,input().split()))
print(("0" if x-t<0 else x-t)) | p03609 |
X,t=list(map(int,input().split()))
if (X-t)<0:
print("0")
else:
print((X-t))
| X,t=list(map(int,input().split()))
print((max(X-t,0))) | p03609 |
class RangeMaximumQuery:
def __init__(self, n):
self.size = n
self.dat = [0] * (2 * n - 1)
def update(self, i, x):
i += self.size - 1
self.dat[i] = x
while i > 0:
i = (i - 1) // 2
d1 = self.dat[i * 2 + 1]
d2 = self.dat[i * 2 + 2]
if d1 > d2:
self.dat[i] = d1
else:
self.dat[i] = d2
def getmax(self, a, b, k, l, r):
if r <= a or b <= l:
return 0
elif a <= l and r <= b:
return self.dat[k]
else:
vl = self.getmax(a, b, k * 2 + 1, l, (l + r) // 2)
vr = self.getmax(a, b, k * 2 + 2, (l + r) // 2, r)
if vl > vr:
return vl
else:
return vr
def solve():
from math import ceil, log
n = int(eval(input()))
A = list(map(int, input().split()))
s = 2 ** ceil(log(n, 2))
W = RangeMaximumQuery(s)
for a_i in A:
cost = W.getmax(0, a_i - 1, 0, 0, s) + a_i
W.update(a_i - 1, cost)
ans = n * (n + 1) // 2 - W.getmax(0, n, 0, 0, s)
print(ans)
solve()
| def solve():
n = int(eval(input()))
dp = [0] * (n + 1)
def update(i, x):
while i <= n:
if dp[i] < x:
dp[i] = x
i += i & -i
def get_sum(i):
s = 0
while i > 0:
t = dp[i]
if s < t:
s = t
i -= i & -i
return s
A = list(map(int, input().split()))
for a_i in A:
update(a_i, get_sum(a_i - 1) + a_i)
ans = n * (n + 1) // 2 - get_sum(n)
print(ans)
solve()
| p01545 |
from itertools import accumulate
N=int(eval(input()))
t=[]
s=list(map(int,input().split()))
for i in range(2,N-1):
p=10**9
for j in range(1,len(s[:i])):
a=sum(s[:i][:j])
b=sum(s[:i][j:])
q=abs(a-b)
if p>q:
p=q
(x,y)=(a,b)
p=10**9
for j in range(1,len(s[i:])):
a=sum(s[i:][:j])
b=sum(s[i:][j:])
q=abs(a-b)
if p>q:
p=q
(x1,y1)=(a,b)
l=(x,y,x1,y1)
t.append(max(l)-min(l))
print((min(t))) | from itertools import accumulate
N=int(eval(input()))
s=list(accumulate(list(map(int,input().split()))))
ans=10**9
p=0
q=2
for i in range(2,N-1):
while p<i-1 and abs(s[i-1]-2*s[p+1])<abs(s[i-1]-2*s[p]):
p+=1
if q<i:
q+=1
while q<N and abs(s[i-1]-2*s[q+1]+s[-1])<abs(s[i-1]-2*s[q]+s[-1]):
q+=1
t=[s[q]-s[i-1],s[-1]-s[q],s[p],s[i-1]-s[p]]
w=max(t)-min(t)
ans=min(ans,w)
print(ans) | p03310 |
from itertools import accumulate
N=int(eval(input()))
s=list(accumulate(list(map(int,input().split()))))
ans=s[-1]
p=0
q=2
for i in range(2,N-1):
while abs(s[i-1]-2*s[p])>abs(s[i-1]-2*s[p+1]):
p+=1
while abs(s[q]*2-s[i-1]-s[-1])>abs(s[q+1]*2-s[i-1]-s[-1]):
q+=1
t=[s[i-1]-s[p],s[p],s[q]-s[i-1],s[-1]-s[q]]
ans=min(ans,max(t)-min(t))
print(ans) | from itertools import accumulate
N=int(eval(input()))
s=list(accumulate(list(map(int,input().split()))))
def f(N,s):
ans=s[-1]
p=0
q=2
for i in range(2,N-1):
while abs(s[i-1]-2*s[p])>abs(s[i-1]-2*s[p+1]):
p+=1
while abs(s[q]*2-s[i-1]-s[-1])>abs(s[q+1]*2-s[i-1]-s[-1]):
q+=1
t=[s[i-1]-s[p],s[p],s[q]-s[i-1],s[-1]-s[q]]
ans=min(ans,max(t)-min(t))
print(ans)
return
f(N,s) | p03310 |
from itertools import accumulate
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
A = list(accumulate(A))
ans = float('inf')
# 切る位置を全探索
for mid in range(2, N - 1):
L, R = A[:mid], A[mid:]
L_target, R_target = L[-1] / 2, (L[-1] + R[-1]) / 2
L_index, R_index = bisect_left(L, L_target), bisect_left(R, R_target)
if abs(L[L_index - 1] - L_target) < abs(L[L_index] - L_target):
L_index -= 1
if abs(R[R_index - 1] - R_target) < abs(R[R_index] - R_target):
R_index -= 1
P, Q, R, S = L[L_index], L[-1]-L[L_index], R[R_index]-L[-1], R[-1]-R[R_index]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| from itertools import accumulate
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
A = list(accumulate(A))
ans = float('inf')
# 切る位置を全探索
for mid in range(1, N):
L_target, R_target = A[mid] // 2, (A[mid] + A[-1]) // 2
L_index, R_index = bisect_left(A, L_target), bisect_left(A, R_target)
if abs(A[L_index - 1] - L_target) < abs(A[L_index] - L_target):
L_index -= 1
if abs(A[R_index - 1] - R_target) < abs(A[R_index] - R_target):
R_index -= 1
P, Q, R, S = A[L_index], A[mid]-A[L_index], A[R_index]-A[mid], A[-1]-A[R_index]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| p03310 |
N = int(eval(input()))
A = list(map(int,input().split()))
S = [0]
for i in range(N):
S.append(S[i]+A[i])
a_before = 1
c_before = 3
ans_tmp = []
for b in range(2,N-1):
if S[a_before] > S[b] - S[a_before]:
a=a_before
else:
for i in range(a_before,b):
if S[i] > S[b] - S[i]:
if abs(S[b]-S[i-1]-S[i-1]) < abs(S[b]-S[i]-S[i]):
a=i-1
a_before = i-1
break
else:
a=i
a_before = i
break
else:
a=b-1
a_before = b-1
if S[c_before] - S[b] > S[N] - S[c_before]:
c=c_before
else:
for i in range(c_before,N):
if S[i] - S[b] > S[N] - S[i]:
if abs((S[N]-S[i-1]) - (S[i-1]-S[b])) < abs((S[N]-S[i]) - (S[i]-S[b])):
c=i-1
c_before = i-1
break
else:
c=i
c_before = i
break
else:
c=N-1
c_before = N-1
ans_tmp.append(max(S[N]-S[c],S[c]-S[b],S[b]-S[a],S[a]-S[0])-min(S[N]-S[c],S[c]-S[b],S[b]-S[a],S[a]-S[0]))
print((min(ans_tmp))) | N = int(eval(input()))
A = list(map(int,input().split()))
S = [0]
for i in range(N):
S.append(S[i]+A[i])
a = 1
c = 3
ans_tmp = []
for b in range(2,N-1):
while abs(S[b]-S[a]-S[a]) > abs(S[b]-S[a+1]-S[a+1]):
a += 1
while abs((S[N]-S[c]) - (S[c]-S[b])) > abs((S[N]-S[c+1]) - (S[c+1]-S[b])):
c += 1
ans_tmp.append(max(S[N]-S[c],S[c]-S[b],S[b]-S[a],S[a]-S[0])-min(S[N]-S[c],S[c]-S[b],S[b]-S[a],S[a]-S[0]))
print((min(ans_tmp))) | p03310 |
#!/usr/bin/env python3
import bisect
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
B = []
t = 0
for a in A:
t += a
B.append(t)
i2 = bisect.bisect_left(B, B[N - 1] / 2, lo = 1, hi = N - 2)
i1 = bisect.bisect_left(B, B[i2] / 2, hi = i2)
i3 = bisect.bisect_left(B, (B[N - 1] + B[i2]) / 2, lo = i2 + 1)
P = B[i1]
Q = B[i2] - B[i1]
R = B[i3] - B[i2]
S = B[N - 1] - B[i3]
min_d = max(P, Q, R, S) - min(P, Q, R, S)
min_half = B[N - 1] / 2 - min_d
max_half = B[N - 1] / 2 + min_d
i2_lo = bisect.bisect_left(B, min_half, lo = 1, hi = N - 2)
i2_hi = bisect.bisect_left(B, max_half, lo = i2_lo, hi = N - 2)
for i2 in range(i2_lo, i2_hi + 1):
if min_d * 2 < abs(B[N - 1] - 2 * B[i2]):
continue
i1 = bisect.bisect_left(B, B[i2] / 2, hi = i2)
i3 = bisect.bisect_left(B, (B[N - 1] + B[i2]) / 2, lo = i2 + 1)
i1_lo = i1_hi = i1
i3_lo = i3_hi = i3
if B[i1] * 2 != B[i2] and 0 < i1:
i1_lo -= 1
if B[i3] * 2 != B[N - 1] + B[i2] and i2 + 1 < i3:
i3_lo -= 1
for i1 in range(i1_lo, i1_hi + 1):
for i3 in range(i3_lo, i3_hi + 1):
P = B[i1]
Q = B[i2] - B[i1]
R = B[i3] - B[i2]
S = B[N - 1] - B[i3]
d = max(P, Q, R, S) - min(P, Q, R, S)
if d < min_d:
min_d = d
print(min_d)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import bisect
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
B = []
t = 0
for a in A:
t += a
B.append(t)
T = B[N - 1]
i2 = bisect.bisect_left(B, T / 2, lo = 1, hi = N - 2)
i1 = bisect.bisect_left(B, B[i2] / 2, hi = i2)
i3 = bisect.bisect_left(B, (T + B[i2]) / 2, lo = i2 + 1)
P = B[i1]
Q = B[i2] - B[i1]
R = B[i3] - B[i2]
S = T - B[i3]
min_d = max(P, Q, R, S) - min(P, Q, R, S)
min_half = T / 2 - min_d
max_half = T / 2 + min_d
i2_lo = bisect.bisect_left(B, min_half, lo = 1, hi = N - 2)
i2_hi = bisect.bisect_left(B, max_half, lo = i2_lo, hi = N - 2)
for i2 in range(i2_lo, i2_hi + 1):
if min_d * 2 < abs(T - 2 * B[i2]):
continue
i1 = bisect.bisect_left(B, B[i2] / 2, hi = i2)
i3 = bisect.bisect_left(B, (T + B[i2]) / 2, lo = i2 + 1)
i1_lo = i1_hi = i1
i3_lo = i3_hi = i3
if B[i1] * 2 != B[i2] and 0 < i1:
i1_lo -= 1
if B[i3] * 2 != T + B[i2] and i2 + 1 < i3:
i3_lo -= 1
for i1 in range(i1_lo, i1_hi + 1):
for i3 in range(i3_lo, i3_hi + 1):
P = B[i1]
Q = B[i2] - B[i1]
R = B[i3] - B[i2]
S = T - B[i3]
d = max(P, Q, R, S) - min(P, Q, R, S)
if d < min_d:
min_d = d
print(min_d)
if __name__ == '__main__':
main()
| p03310 |
import sys
from bisect import bisect_left as bl
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int,input().split()))
cs = [0] * N
cs[0] = a[0]
for i in range(N - 1): cs[i + 1] = cs[i] + a[i + 1]
res = float("inf")
for m in range(1, N - 1):
l = bl(cs[: m], cs[m] // 2)
r = bl(cs[m: ], cs[m] + (cs[-1] - cs[m]) // 2) + m
l -= l == m
r += r == m
nl = l + 0
nr = r + 0
for i in range(3):
if i == 1: continue
if 0 <= l + i - 1 < m:
if abs(cs[m] - 2 * cs[l + i - 1]) < abs(cs[m] - 2 * cs[l]):
nl = l + i - 1
if m < r + i - 1 < N:
if abs(cs[-1] - 2 * cs[r + i - 1] + cs[m]) < abs(cs[-1] - 2 * cs[r] + cs[m]):
nr = r + i - 1
l = nl
r = nr
res = min(res, max(cs[l], cs[m] - cs[l], cs[r] - cs[m], cs[-1] - cs[r]) - min(cs[l], cs[m] - cs[l], cs[r] - cs[m], cs[-1] - cs[r]))
print(res) | import sys
from bisect import bisect_left as bl
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int,input().split()))
cs = [0] * N
cs[0] = a[0]
for i in range(N - 1): cs[i + 1] = cs[i] + a[i + 1]
res = float("inf")
for m in range(1, N - 1):
l = bl(cs, cs[m] // 2, hi = m)
r = bl(cs, cs[m] + (cs[-1] - cs[m]) // 2, lo = m)
l -= l == m
r += r == m
nl = l + 0
nr = r + 0
for i in range(3):
if i == 1: continue
if 0 <= l + i - 1 < m:
if abs(cs[m] - 2 * cs[l + i - 1]) < abs(cs[m] - 2 * cs[l]):
nl = l + i - 1
if m < r + i - 1 < N:
if abs(cs[-1] - 2 * cs[r + i - 1] + cs[m]) < abs(cs[-1] - 2 * cs[r] + cs[m]):
nr = r + i - 1
l = nl
r = nr
res = min(res, max(cs[l], cs[m] - cs[l], cs[r] - cs[m], cs[-1] - cs[r]) - min(cs[l], cs[m] - cs[l], cs[r] - cs[m], cs[-1] - cs[r]))
print(res) | p03310 |
import itertools
n = int(eval(input()))
lst = list(map(int, input().split()))
lst_accum = list(itertools.accumulate(lst))
def shaku(lst_accum, first):
all_sum = lst_accum[-1]
min_diff = 10**100
for k in range(len(lst_accum)-1):
diff = abs(all_sum - 2*lst_accum[k] + first)
if min_diff > diff:
index = k
min_diff = diff
P = lst_accum[k] - first
return P, all_sum - P - first
min_diff = 10**100
for k in range(1, len(lst_accum)-2):
lst_first = lst_accum[:k+1]
lst_second = lst_accum[k+1:]
#print('length_first: ', len(lst_first))
P, Q = shaku(lst_first, 0)
#print('length_second: ', len(lst_second))
R, S = shaku(lst_second, lst_accum[k])
min_diff = min(min_diff, max(P, Q, R, S) - min(P, Q, R, S))
print(min_diff) | import itertools
n = int(eval(input()))
lst = list(map(int, input().split()))
lst_accum = list(itertools.accumulate(lst))
min_diff = 10**100
first_cut = 0
third_cut = 2
all_sum = lst_accum[-1]
for k in range(1, len(lst_accum)-2):
second_last = lst_accum[k]
P = lst_accum[first_cut]
Q = second_last - P
diff = abs(P-Q)
while k - first_cut > 1 and diff > abs(second_last - lst_accum[first_cut+1]*2):
first_cut += 1
P = lst_accum[first_cut]
Q = second_last - P
diff = abs(P-Q)
if third_cut == k:
third_cut += 1
third_last = lst_accum[third_cut]
S = all_sum - third_last
R = third_last - second_last
diff = abs(S-R)
while (n-1) - third_cut > 1 and diff > abs(all_sum - lst_accum[third_cut+1]*2 + second_last):
third_cut += 1
third_last = lst_accum[third_cut]
S = all_sum - third_last
R = third_last - second_last
diff = abs(S-R)
#print(first_cut, k, third_cut)
min_diff = min(min_diff, max(P,Q,R,S) - min(P,Q,R,S))
#print(min_diff)
print(min_diff) | p03310 |
n = int(eval(input()))
A = list(map(int, input().split()))
F = [int()] * n
F[0] = A[0]
for b in range(1, n):
F[b] = F[b - 1] + A[b]
res = [0]*4
data = [10 ** 18] * 2
ex = [0]*4
ans = 10 ** 18
s = 0
t = 2
for i in range(1, n - 2):
bl = [True, True]
for j in range(s, i):
res[0] = F[j]
res[1] = F[i] - F[j]
if not bl[0]:
break
if data[0] > abs(res[1] - res[0]) or j == s:
s = j
ex[0] = res[0]
ex[1] = res[1]
data[0] = abs(res[1] - res[0])
else:
bl[0] = False
for k in range(t, n):
res[2] = F[k] - F[i]
res[3] = F[n - 1] - F[k]
if not bl[1]:
break
if data[1] > abs(res[3] - res[2]) or k == t:
t = k
ex[2] = res[2]
ex[3] = res[3]
data[1] = abs(res[3] - res[2])
else:
bl[1] = False
ans = min(ans, max(ex) - min(ex))
print(ans) | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
A = list(map(int, input().split()))
F = [int()] * n
F[0] = A[0]
for b in range(1, n):
F[b] = F[b - 1] + A[b]
res = [0]*4
data = [10 ** 18] * 2
ex = [0]*4
ans = 10 ** 18
s = 0
t = 2
for i in range(1, n - 2):
bl = [True, True]
for j in range(s, i):
res[0] = F[j]
res[1] = F[i] - F[j]
if not bl[0]:
break
if data[0] > abs(res[1] - res[0]) or j == s:
s = j
ex[0] = res[0]
ex[1] = res[1]
data[0] = abs(res[1] - res[0])
else:
bl[0] = False
for k in range(t, n):
res[2] = F[k] - F[i]
res[3] = F[n - 1] - F[k]
if not bl[1]:
break
if data[1] > abs(res[3] - res[2]) or k == t:
t = k
ex[2] = res[2]
ex[3] = res[3]
data[1] = abs(res[3] - res[2])
else:
bl[1] = False
ans = min(ans, max(ex) - min(ex))
print(ans)
if __name__ == '__main__':
main()
| p03310 |
INF = float('inf')
from bisect import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
S = [0]*N
for i in range(N):
S[i] = S[i-1]+A[i]
ans = INF
for i in range(2,N-1):
l = S[:i]
r = S[i:]
j = bisect(l,l[-1]/2)
k = bisect(r,(r[-1]+l[-1])/2)
for p in {j-1,min(j,len(l)-2)}:
for q in {k-1,min(k,len(r)-2)}:
a,b,c,d = l[p],l[-1]-l[p],r[q]-l[-1],r[-1]-r[q]
m = min(a,b,c,d)
M = max(a,b,c,d)
ans = min(ans,M-m)
print(ans)
| INF = float('inf')
from bisect import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
S = [0]*N
for i in range(N):
S[i] = S[i-1]+A[i]
ans = INF
for i in range(2,N-1):
j = bisect(S,S[i-1]/2)
k = bisect(S,(S[-1]+S[i-1])/2)
for p in {j-1,min(j,i-2)}:
for q in {k-1,i,min(k,N-2)}:
a,b,c,d = S[p],S[i-1]-S[p],S[q]-S[i-1],S[-1]-S[q]
m = min(a,b,c,d)
M = max(a,b,c,d)
ans = min(ans,M-m)
print(ans) | p03310 |
from statistics import mean
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 = float('inf')
for middle in range(1, N - 2):
left_middle = 0
right_middle = middle + 1
left_sum = S[left_middle]
right_sum = S[middle] - left_sum
diff = abs(left_sum - right_sum)
for i in range(left_middle+1, middle):
left_sum = S[i]
right_sum = S[middle] - left_sum
if diff > abs(left_sum - right_sum):
left_middle = i
diff = abs(left_sum - right_sum)
else:
break
left_sum = S[right_middle] - S[middle]
right_sum = S[-1] - S[right_middle]
diff = abs(left_sum - right_sum)
for i in range(right_middle + 1, N):
left_sum = S[i] - S[middle]
right_sum = S[-1] - S[i]
if diff > abs(left_sum - right_sum):
right_middle = i
diff = abs(left_sum - right_sum)
else:
break
s1 = S[left_middle]
s2 = S[middle] - s1
s3 = S[right_middle] - s1 - s2
s4 = S[-1] - s1 - s2 - s3
score = max(s1, s2, s3, s4) - min(s1, s2, s3, s4)
ans = min(ans, score)
print(ans)
| from statistics import mean
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])
left_middle = 0
right_middle = 2
ans = float('inf')
for middle in range(1, N - 2):
left_sum = S[left_middle]
right_sum = S[middle] - left_sum
diff = abs(left_sum - right_sum)
for i in range(left_middle+1, middle):
left_sum = S[i]
right_sum = S[middle] - left_sum
if diff > abs(left_sum - right_sum):
left_middle = i
diff = abs(left_sum - right_sum)
else:
break
left_sum = S[right_middle] - S[middle]
right_sum = S[-1] - S[right_middle]
diff = abs(left_sum - right_sum)
for i in range(right_middle + 1, N):
left_sum = S[i] - S[middle]
right_sum = S[-1] - S[i]
if diff > abs(left_sum - right_sum):
right_middle = i
diff = abs(left_sum - right_sum)
else:
break
s1 = S[left_middle]
s2 = S[middle] - s1
s3 = S[right_middle] - s1 - s2
s4 = S[-1] - s1 - s2 - s3
score = max(s1, s2, s3, s4) - min(s1, s2, s3, s4)
ans = min(ans, score)
print(ans)
| p03310 |
from itertools import accumulate
import bisect
n = int(eval(input()))
a = list(map(int, input().split()))
arev = list(reversed(a))
front = list(accumulate(a))
back = list(accumulate(arev))
ans = float('inf')
for i in range(1,n-2):
b = bisect.bisect_left(front,front[i]//2,0,i-1)
c = bisect.bisect_left(back,back[n-i-2]//2,0,n-i-3)
p = front[b]
q = front[i]-front[b]
s = back[c]
r = back[n-i-2]-back[c]
ans = min(max(p,q,r,s)-min(p,q,r,s),ans)
if b!=0:
p = front[b-1]
q = front[i] - front[b-1]
s = back[c]
r = back[n-i-2] - back[c]
ans = min(max(p, q, r, s) - min(p, q, r, s), ans)
if c!=0:
p = front[b]
q = front[i] - front[b]
s = back[c-1]
r = back[n-i-2] - back[c-1]
ans = min(max(p, q, r, s) - min(p, q, r, s), ans)
if b!=0 and c!=0:
p = front[b-1]
q = front[i] - front[b-1]
s = back[c-1]
r = back[n-i-2] - back[c-1]
ans = min(max(p, q, r, s) - min(p, q, r, s), ans)
print(ans)
| # 解説の方法
from itertools import accumulate
n = int(eval(input()))
a = list(map(int, input().split()))
acc = list(accumulate(a))
l = 0
r = 2
ans = float('inf')
for y in range(1,n-2):
for x in range(l,y-1):
if abs(acc[y]-acc[x]*2)>=abs(acc[y]-acc[x+1]*2):
l = x+1
continue
else:
break
r = max(y+1,r)
for z in range(r,n-2):
if abs(acc[n-1]-acc[z]*2+acc[y])>=abs(acc[n-1]-acc[z+1]*2+acc[y]):
r = z+1
continue
else:
break
P = acc[l]
Q = acc[y] - acc[l]
R = acc[r] - acc[y]
S = acc[n-1] - acc[r]
ans = min(ans, max(P,Q,R,S)-min(P,Q,R,S))
print(ans)
| p03310 |
n=int(eval(input()))
a=[int(i) for i in input().split()]
s=sum(a)
ans=s
b=a[0]
for i in range(n-3):
b=0
for l in range(i+2):
b+=a[l]
c=s-b
j=0
k=0
while k-b/2<0:
k+=a[j]
j+=1
if k-b/2>b/2+a[j-1]-k:
k-=a[j-1]
x=min(k,b-k)
y=max(k,b-k)
j=-1
k=0
while k-c/2<0:
k+=a[j]
j-=1
if k-c/2>c/2+a[j+1]-k:
k-=a[j+1]
z=min(k,c-k)
w=max(k,c-k)
t=max(y,w)-min(x,z)
if ans>t:
ans=t
print(ans) | n=int(eval(input()))
a=[int(i) for i in input().split()]
s=[a[0]]
for i in range(n-1):
s.append(s[i]+a[i+1])
ans=s[n-1]
j=0
k=2
for i in range(1,n-2):
while abs(s[i]-2*s[j]) > abs(s[i]-2*s[j+1]):
j=j+1
while abs(s[n-1]-2*s[k]+s[i]) > abs(s[n-1]-2*s[k+1]+s[i]):
k=k+1
t=max(s[j],s[i]-s[j],s[k]-s[i],s[n-1]-s[k])-min(s[j],s[i]-s[j],s[k]-s[i],s[n-1]-s[k])
if ans>t:
ans=t
print(ans)
| p03310 |
from itertools import accumulate as acc
from bisect import bisect_left as bl
def ans(n):
tmp=0
for i in range(N):
tmp+=abs(a[i]-a[n-1])
return tmp
N=int(eval(input()))
a=list(map(int,input().split()))
a=list(acc(a))
ans=10**18
p=0
q=2
for j in range(1,N-2):
q=min(q,j+1)
while p<j-1 and abs(a[j]-a[p]*2)>abs(a[j]-a[p+1]*2):
p+=1
while q<N-2 and abs(a[j]+a[N-1]-a[q]*2)>abs(a[j]+a[N-1]-a[q+1]*2):
q+=1
P,Q,R,S=a[p], a[j]-a[p], a[q]-a[j], a[N-1]-a[q]
ans=min(ans, max(P,Q,R,S)-min(P,Q,R,S))
print(ans) | from itertools import accumulate as acc
from bisect import bisect_left as bl
def ans(n):
tmp=0
for i in range(N):
tmp+=abs(a[i]-a[n-1])
return tmp
N=int(eval(input()))
a=list(map(int,input().split()))
a=list(acc(a))
ans=10**18
p=0
q=2
for j in range(1,N-2):
q=max(q,j+1)
while p<j-1 and abs(a[j]-a[p]*2)>abs(a[j]-a[p+1]*2):
p+=1
while q<N-2 and abs(a[j]+a[N-1]-a[q]*2)>abs(a[j]+a[N-1]-a[q+1]*2):
q+=1
P,Q,R,S=a[p], a[j]-a[p], a[q]-a[j], a[N-1]-a[q]
ans=min(ans, max(P,Q,R,S)-min(P,Q,R,S))
print(ans) | p03310 |
from itertools import accumulate
from bisect import bisect
def half(T, h):
b = bisect(T,h)
if abs(T[b-1]*2 - T[-1] - T[0]) <= abs(T[b]*2 - T[-1] - T[0]):
return T[b-1] - T[0], T[-1]-T[b-1]
return T[b] - T[0], T[-1]-T[b]
N = int( eval(input()))
A = list( map( int, input().split()))
S = [0] + list( accumulate(A))
ans = 10**9+1
for i in range(2, N-1):
x, y = half(S[:i+1], S[i]//2)
z, w = half(S[i:], (S[i] + S[-1])//2)
m = min(x,y,z,w)
M = max(x,y,z,w)
if M-m < ans:
ans = M-m
print(ans)
| from itertools import accumulate
N = int( eval(input()))
A = list( map( int, input().split()))
a, b = 0, 2
ans = 10**9 + 1
S = list(accumulate(A))
for i in range(1,N-2):
while S[a] < S[i] - S[a+1]:
a += 1
b = max(b,i+1)
while S[b] - S[i] < S[-1] - S[b+1]:
b += 1
ans = min( ans, max(S[a], S[i] - S[a], S[b] - S[i], S[-1] - S[b]) - min(S[a], S[i] - S[a], S[b] - S[i], S[-1] - S[b]))
print(ans) | p03310 |
N=int(eval(input()))
alist=list(map(int,input().split()))
def bs_left(mid,mp):
sum2=abs(2*slist[mid]-slist[mp])
if mid==0:
sum1=sum2
else:
sum1=abs(2*slist[mid-1]-slist[mp])
if mid==mp:
sum3=sum2
else:
sum3=abs(2*slist[mid+1]-slist[mp])
if sum2<=sum1 and sum2<=sum3:
return 0
elif sum1<sum2:
return -1
elif sum2>sum3:
return 1
def bs_right(mid,mp):
sum2=abs(2*(slist[mid]-slist[mp])-(slist[-1]-slist[mp]))
if mid==0:
sum1=sum2
else:
sum1=abs(2*(slist[mid-1]-slist[mp])-(slist[-1]-slist[mp]))
if mid==mp:
sum3=sum2
else:
sum3=abs(2*(slist[mid+1]-slist[mp])-(slist[-1]-slist[mp]))
if sum2<=sum1 and sum2<=sum3:
return 0
elif sum1<sum2:
return -1
elif sum2>sum3:
return 1
slist=[]
asum=0
for a in alist:
asum+=a
slist.append(asum)
#print(alist)
#print(slist)
dic_lp,dic_rp={},{}
for mp in range(1,N-2):
#lp
l,r=0,mp-1
while(l<=r):
mid=(l+r)//2
ret=bs_left(mid,mp)
if ret==1:
l=mid+1
elif ret==-1:
r=mid-1
else:
dic_lp[mp]=mid
#print(mp,mid)
break
#rp
l,r=mp+1,N-2
while(l<=r):
mid=(l+r)//2
ret=bs_right(mid,mp)
if ret==1:
l=mid+1
elif ret==-1:
r=mid-1
else:
dic_rp[mp]=mid
#print(mp,mid)
break
min_diff=10**9
for mp in range(1,N-2):
lp=dic_lp[mp]
rp=dic_rp[mp]
sum1=slist[lp]
sum2=slist[mp]-slist[lp]
sum3=slist[rp]-slist[mp]
sum4=slist[-1]-slist[rp]
#print(sum1,sum2,sum3,sum4)
sum_list=[sum1,sum2,sum3,sum4]
sum_list.sort()
diff=sum_list[-1]-sum_list[0]
#print(lp,mp,rp,diff)
if diff<min_diff:
min_diff=diff
print(min_diff)
| N=int(eval(input()))
alist=list(map(int,input().split()))
def bs_left(mid,mp):
sum1=sum2=abs(2*slist[mid]-slist[mp])
sum3=abs(2*slist[mid+1]-slist[mp])
if mid>0:
sum1=abs(2*slist[mid-1]-slist[mp])
if sum2<=sum1 and sum2<=sum3:
return 0
elif sum1<sum2:
return -1
elif sum2>sum3:
return 1
def bs_right(mid,mp):
sum1=abs(2*(slist[mid-1]-slist[mp])-(slist[-1]-slist[mp]))
sum2=abs(2*(slist[mid]-slist[mp])-(slist[-1]-slist[mp]))
sum3=abs(2*(slist[mid+1]-slist[mp])-(slist[-1]-slist[mp]))
if sum2<=sum1 and sum2<=sum3:
return 0
elif sum1<sum2:
return -1
elif sum2>sum3:
return 1
slist=[]
asum=0
for a in alist:
asum+=a
slist.append(asum)
#print(alist)
#print(slist)
dic_lp,dic_rp={},{}
for mp in range(1,N-2):
#lp
l,r=0,mp-1
while(l<=r):
mid=(l+r)//2
ret=bs_left(mid,mp)
if ret==1:
l=mid+1
elif ret==-1:
r=mid-1
else:
dic_lp[mp]=mid
#print(mp,mid)
break
#rp
l,r=mp+1,N-2
while(l<=r):
mid=(l+r)//2
ret=bs_right(mid,mp)
if ret==1:
l=mid+1
elif ret==-1:
r=mid-1
else:
dic_rp[mp]=mid
#print(mp,mid)
break
min_diff=10**9
for mp in range(1,N-2):
lp=dic_lp[mp]
rp=dic_rp[mp]
sum1=slist[lp]
sum2=slist[mp]-slist[lp]
sum3=slist[rp]-slist[mp]
sum4=slist[-1]-slist[rp]
#print(sum1,sum2,sum3,sum4)
sum_list=[sum1,sum2,sum3,sum4]
sum_list.sort()
diff=sum_list[-1]-sum_list[0]
#print(lp,mp,rp,diff)
if diff<min_diff:
min_diff=diff
print(min_diff) | p03310 |
from itertools import accumulate
from bisect import bisect_left, bisect_right
n = int(eval(input()))
a = list(map(int, input().split()))
ts = list(accumulate(a))+[0]
r = 0
def calc(st, ed):
t0 = ts[ed-1] - ts[st-1]
i1 = bisect_left(ts, (ts[ed-1]+ts[st-1])/2, st+1, ed-1)
t11 = ts[i1-1] - ts[st-1]
t12 = t0 - t11
t21 = ts[i1] - ts[st-1]
t22 = t0 - t21
if abs(t22-t21) > abs(t12-t11):
return t11, t12
else:
return t21, t22
ans = 10**18
for i in range(2, n-1):
r1, r2 = calc(0, i)
r3, r4 = calc(i, n)
# print(r1, r2, r3, r4)
diff = max([r1, r2, r3, r4]) - min([r1, r2, r3, r4])
ans = min(ans, diff)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
from itertools import accumulate
accum = list(accumulate(a))
i_left = 0
i_right = 2
ans = 10**18
for i in range(1, n-2):
while True:
p = accum[i_left]
q = accum[i] - p
p_new = accum[i_left+1]
q_new = accum[i] - p_new
if abs(p_new - q_new) < abs(p - q):
i_left += 1
else:
break
while True:
r = accum[i_right] - accum[i]
s = accum[-1] - accum[i_right]
r_new = accum[i_right+1] - accum[i]
s_new = accum[-1] - accum[i_right+1]
if abs(r_new - s_new) < abs(r - s):
i_right += 1
else:
break
# print(p, q, r, s)
diff = max([p, q, r, s]) - min([p, q, r, s])
ans = min(ans, diff)
print(ans)
| p03310 |
import sys
from itertools import accumulate
from bisect import bisect_left as bi_l
n, *a = list(map(int, sys.stdin.read().split()))
def main():
s = list(accumulate(a))
ans = float('inf')
for center in range(1, n-2):
pq = s[center]
left = bi_l(s, pq / 2)
if left == 0:
p = s[0]
else:
if pq - s[left] < s[left-1]:
left -= 1
p = s[left]
q = pq - p
rt = s[-1] - pq
right = bi_l(s, pq + rt / 2)
if right == center + 1:
r = s[center+1] - pq
else:
if rt - (s[right] - pq) < s[right-1] - pq:
right -= 1
r = s[right] - pq
t = rt - r
res = sorted([p, q, r, t])
ans = min(ans, res[-1] - res[0])
return ans
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from itertools import accumulate
n, *a = list(map(int, sys.stdin.read().split()))
def main():
ans = float('inf')
left = 0; right = 2
p = a[0]; q = 0; r = sum(a[1:3]); s = sum(a[3:])
for c in range(1, n-2):
q += a[c]; r -= a[c]
while left < c - 1:
nex = a[left+1]
if abs((q - nex) - (p + nex)) <= abs(q - p):
q -= nex; p += nex
left += 1
else:
break
while right < n - 2:
nex = a[right+1]
if abs((s - nex) - (r + nex)) <= abs(s - r):
s -= nex; r += nex
right += 1
else:
break
res = sorted([p, q, r, s])
ans = min(ans, res[-1] - res[0])
return ans
if __name__ == '__main__':
ans = main()
print(ans) | p03310 |
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i - 1]
def calc(lst, min_num):
total = lst[-1] - min_num
# print (total)
lb = -1
ub = len(lst)
while (ub - lb) > 1:
mid = (lb + ub)//2
if lst[mid] - min_num > total/2:
ub = mid
else:
lb = mid
# print ('ub', ub)
a1, b1 = lst[ub] - min_num, lst[-1] - lst[ub]
diff1 = abs(b1 - a1)
# print ('diff1', diff1)
a2, b2 = lst[ub - 1] - min_num, lst[-1] - lst[ub - 1]
diff2 = abs(b2 - a2)
# print ('diff2', diff2)
if diff2 < diff1:
a1, b1 = a2, b2
return a1, b1
# print (calc(A, 0))
ans = 10 ** 9
for half in range(2, N - 1):
# print (A[:half], end = ' ')
# print (A[half:])
P, Q = calc(A[:half], 0)
R, S = calc(A[half:], A[half - 1])
# print (P, Q, R, S)
tmp = max(P, Q, R, S) - min(P, Q, R, S)
# print (tmp)
ans = min(tmp, ans)
# print ('ans', ans)
print (ans)
| #PypyでもTLE A[:half]のような箇所が遅い？
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i - 1]
def calc(lb, ub):
max_num = A[ub]
lb -= 1
if lb == -1:
min_num = 0
else:
min_num = A[lb]
total = A[ub] - min_num
# print (total)
while (ub - lb) > 1:
mid = (lb + ub)//2
if A[mid] - min_num > total/2:
ub = mid
else:
lb = mid
# print ('ub', ub)
a1, b1 = A[ub] - min_num, max_num - A[ub]
diff1 = abs(b1 - a1)
# print ('diff1', diff1)
a2, b2 = A[ub - 1] - min_num, max_num - A[ub - 1]
diff2 = abs(b2 - a2)
# print ('diff2', diff2)
if diff2 < diff1:
a1, b1 = a2, b2
return a1, b1
# print (calc(A, 0))
# half = 2
# P, Q = calc(0, half - 1)
# print (P, Q)
ans = 10 ** 9
for half in range(2, N - 1):
# print (A[:half], end = ' ')
# print (A[half:])
P, Q = calc(0, half - 1)
R, S = calc(half, N - 1)
# print (P, Q, R, S)
tmp = max(P, Q, R, S) - min(P, Q, R, S)
# print (tmp)
ans = min(tmp, ans)
# print ('ans', ans)
print (ans)
| p03310 |
from itertools import accumulate
def S(a, b):
return cl[b] - (0 if a == 0 else cl[a-1])
def partial(start, end, last):
odiff = None
for c in range(start, end+1):
p = S(start,c)
q = S(c+1,end)
diff = abs(p-q)
if odiff is None:
odiff = diff
if odiff < diff:
return c, mp, mq
odiff = diff
mp = p
mq = q
if __name__ == '__main__':
# read input
n = int(eval(input()))
l = list(map(int, input().split()))
# create cumlative list first
cl = list(accumulate(l))
clen = len(l)
# 0 F(i) i i+1 G(i) len-1
# |------|------|-------|-------|
# c0 c1 c2
# <-----L------> <------R------->
# pick up a c1 (i:i+1) and evaluate
result = None
c1 = 1
c3 = 3
for i in range(1,clen-2):
# LEFT
(c1, mb, mc) = partial(0, i, c1)
# RIGHT
c3, md, me = partial(i+1, clen-1, c3)
# evaluate
diff = abs(max(mb, mc, md, me) - min(mb, mc, md, me))
if result is None:
result = diff
else:
if result > diff:
result = diff
print(result) | from itertools import accumulate
def Sdiff(s, m, e):
# Sdiff(s, m, e) = [A_s, A_s+1 ..., A_m] [A_m+1 .... A_e]
# L = cl[m]-cl[s-1], R = cl[e] - cl[m]
# diff(L,R) = abs(cl[m] - cl[s-1] - cl[e] + cl[m]) = abs(2*cl[m] - cl[s-1] - cl[e])
x = 0 if s == 0 else cl[s-1]
return abs(2*cl[m] - x - cl[e])
def partial(start, end, last):
#print("partial: {}-{} last:{}".format(start,end, last))
odiff = Sdiff(start, last, end)
for c in range(last, end):
diff = Sdiff(start, c, end)
#print("partial loop: c:{}, diff:{} -> {}".format(c, odiff, diff))
if odiff < diff:
return c-1
odiff = diff
return c
if __name__ == '__main__':
# read input
N = int(eval(input()))
l = list(map(int, input().split()))
# create cumlative list first
cl = list(accumulate(l))
# 0 F(i) i i+1 G(i) len-1
# |------|------|-------|-------|
# c0 c1 c2
# <-----L------> <------R------->
# pick up a c1 (i:i+1) and evaluate
result = 9 * 10e9
c1 = 0
c3 = 2
for i in range(1, N-2):
#print("LEFT:RIGHT {}/={}=/{}".format(l[0:i+1], i, l[i+1: N]))
# LEFT
c1 = partial(0, i, c1)
# RIGHT
c3 = partial(i+1, N-1, c3)
# evaluate
mb = cl[c1]
mc = cl[i] - mb
md = cl[c3] - cl[i]
me = cl[N-1] - cl[c3]
diff = abs(max(mb, mc, md, me) - min(mb, mc, md, me))
#print("\t\t{}/{}/{}: [{} {} {} {}]".format(c1, i, c3, mb, mc, md, me))
#print("\t\tdiff={}".format(diff))
if diff < result:
result = diff
print(result) | p03310 |
N = int(eval(input()))
A = list(map(int, input().split()))
cum_sum = [0] + [sum(A[:i + 1]) for i in range(N)]
ans = float("inf")
def get_diff(left, center, right):
return abs((cum_sum[center] - cum_sum[left]) - (cum_sum[right] - cum_sum[center]))
l_point = 1
r_point = 3
for C in range(2, N):
while l_point + 1 < C and get_diff(0, l_point, C) > get_diff(0, l_point + 1, C):
l_point += 1
while r_point + 1 < N and get_diff(C, r_point, N) > get_diff(C, r_point + 1, N):
r_point += 1
pqrs = [cum_sum[l_point], cum_sum[C] - cum_sum[l_point], cum_sum[r_point] - cum_sum[C], cum_sum[N] - cum_sum[r_point]]
ans = min(ans, max(pqrs) - min(pqrs))
print(ans)
| import sys
n = int(eval(input()))
a = list(map(int, input().split()))
aa = [0]
for i in range(n):
aa.append(aa[i] + a[i])
ans = sys.maxsize
def getdiff(left, center, right):
return abs((aa[center] - aa[left]) - (aa[right] - aa[center]))
L = 1
R = 3
for C in range(2, n):
while L + 1 < C and getdiff(0, L, C) > getdiff(0, L + 1, C):
L += 1
while R + 1 < n and getdiff(C, R, n) > getdiff(C, R + 1, n):
R += 1
pqrs = [aa[L], aa[C] - aa[L], aa[R] - aa[C], aa[n] - aa[R]]
pqrs.sort()
ans = min(ans, pqrs[3] - pqrs[0])
print(ans) | p03310 |
#dame datta
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
Al = [A[0]]
r = (10**9)*(2*(10**5))
for i in A[1:]:
Al.append(Al[-1] + i)
for t in range(2, N-1):
t1 = -1
m = (10**9)*(2*(10**5))
for i in range(1,t):
ii = abs(Al[t-1] - Al[i-1] - Al[i-1])
if m > ii:
t1 = i
m = ii
t2 = -1
m = (10**9)*(2*(10**5))
for i in range(t+1, N):
ii = abs(Al[-1] - Al[i-1] - Al[i-1] + Al[t-1])
if m > ii:
t2 = i
m = ii
x = Al[-1] - Al[t2-1]
y = Al[t2-1] - Al[t-1]
z = Al[t-1] - Al[t1-1]
w = Al[t1-1]
r = min(max(x,y,z,w) - min(x,y,z,w), r)
return r
print((main()))
| #dame datta
def binsearch(l, r, fn):
while r - l > 1:
m = (l + r) // 2
t = fn(m+1) - fn(m)
if t == 0:
return fn(m)
if t < 0:
l = m + 1
else:
r = m
if fn(l) < fn(r):
return l
else:
return r
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
Al = [A[0]]
r = (10**9)*(2*(10**5))
for i in A[1:]:
Al.append(Al[-1] + i)
for t in range(2, N-1):
def fn1(i):
return abs(Al[t-1] - Al[i-1] - Al[i-1])
t1 = binsearch(1, t, fn1)
def fn2(i):
return abs(Al[-1] - Al[i-1] - Al[i-1] + Al[t-1])
t2 = binsearch(t+1, N, fn2)
x = Al[-1] - Al[t2-1]
y = Al[t2-1] - Al[t-1]
z = Al[t-1] - Al[t1-1]
w = Al[t1-1]
r = min(max(x,y,z,w) - min(x,y,z,w), r)
return r
print((main()))
| p03310 |
N=int(eval(input()))
a=[int(i) for i in input().split()]
from itertools import accumulate
l=[0]+list(accumulate(a))
s=l[-1]
ans=10000000000000
import bisect
for i in range(2,N-1):
ll=l[0:i+1]
lr=l[i:N+1]
lls=ll[-1]
lrs=lr[-1]-lr[0]
n=bisect.bisect_left(ll,lls//2)
if n+1>=len(ll):
n=len(ll)-2
elif n+1<0:
n=1
if min(abs(lls-ll[n]*2),abs(lls-ll[n-1]*2),abs(lls-ll[n+1]*2))==abs(lls-ll[n]*2):
s=ll[n]
t=lls-ll[n]
elif min(abs(lls-ll[n]*2),abs(lls-ll[n-1]*2),abs(lls-ll[n+1]*2))==abs(lls-ll[n-1]*2):
s=ll[n-1]
t=lls-ll[n-1]
else:
s=ll[n+1]
t=lls-ll[n+1]
n=bisect.bisect_left(lr,lr[0]+lrs//2)
if n+1>=len(lr):
n=len(lr)-2
elif n-1<0:
n=1
if min(abs(lrs-lr[n]*2+2*lr[0]),abs(lrs-lr[n-1]*2+2*lr[0]),abs(lrs-lr[n+1]*2+2*lr[0]))==abs(lrs-lr[n]*2+2*lr[0]):
u=lr[n]-lr[0]
v=lrs-lr[n]+lr[0]
elif min(abs(lrs-lr[n]*2+2*lr[0]),abs(lrs-lr[n-1]*2+2*lr[0]),abs(lrs-lr[n+1]*2+2*lr[0]))==abs(lrs-lr[n-1]*2+2*lr[0]):
u=lr[n-1]-lr[0]
v=lrs-lr[n-1]+lr[0]
else:
u=lr[n+1]-lr[0]
v=lrs-lr[n+1]+lr[0]
ans=min(ans,max(s,t,u,v)-min(s,t,u,v))
print(ans)
| n=int(eval(input()))
a=[int(i) for i in input().split()]
for i in range(n-1):
a[i+1]+=a[i]
j=0
k=2
ans=10**9
for i in range(1,n-1):
while abs(a[j]*2-a[i])>abs(a[j+1]*2-a[i]):
j+=1
while abs(a[k]*2-a[i]-a[n-1])>abs(a[k+1]*2-a[i]-a[n-1]):
k+=1
t=[a[j],a[i]-a[j],a[k]-a[i],a[n-1]-a[k]]
ans=min(ans,max(t)-min(t))
print(ans)
| p03310 |
# https://atcoder.jp/contests/abc102/tasks/arc100_b
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop
def main():
n = int(eval(input()))
al = list(map(int, input().split()))
l, c, r = 1, 2, 3
P = sum(al[:l])
Q = sum(al[l:c])
R = sum(al[c:r])
S = sum(al[r:])
ans = max(P, Q, R, S) - min(P, Q, R, S)
while c <= n - 2:
while True:
if abs(P - Q) < abs((P + al[l]) - (Q - al[l])): # これ以上差が縮まらないなら break
break
if l == c - 1:
break
P += al[l]
Q -= al[l]
l += 1
while True:
if abs(R - S) < abs((R + al[r]) - (S - al[r])): # これ以上差が縮まらないなら break
break
if r == n - 1:
break
R += al[r]
S -= al[r]
r += 1
ans = min(max(P, Q, R, S) - min(P, Q, R, S), ans)
# center を一つ右に進める
Q += al[c]
R -= al[c]
c += 1
print(ans)
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc102/tasks/arc100_b
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop
def main():
n = int(eval(input()))
al = list(map(int, input().split()))
l, c, r = 1, 2, 3
P = sum(al[:l])
Q = sum(al[l:c])
R = sum(al[c:r])
S = sum(al[r:])
ans = max(P, Q, R, S) - min(P, Q, R, S)
while c <= n - 2:
while True:
if l == c - 1:
break
if abs(P - Q) < abs((P + al[l]) - (Q - al[l])): # これ以上差が縮まらないなら break
break
P += al[l]
Q -= al[l]
l += 1
while True:
if r == n - 1:
break
if abs(R - S) < abs((R + al[r]) - (S - al[r])): # これ以上差が縮まらないなら break
break
R += al[r]
S -= al[r]
r += 1
ans = min(max(P, Q, R, S) - min(P, Q, R, S), ans)
# center を一つ右に進める
Q += al[c]
R -= al[c]
c += 1
print(ans)
if __name__ == '__main__':
main()
| p03310 |
from itertools import accumulate
import bisect
N=int(eval(input()))
A=[int(x) for x in input().split()]
S=list(accumulate(A))
def solve(x):
cnt=S[x]
L=bisect.bisect_left(S,cnt/2)
R=bisect.bisect_left(S,(cnt+S[N-1])/2)
L2=bisect.bisect_right(S,cnt/2)
R2=bisect.bisect_right(S,(cnt+S[N-1])/2)
res=10**10
if R!=N:
ans=[S[L],cnt-S[L],S[R]-cnt,S[N-1]-S[R]]
ans2=[S[L2-1],cnt-S[L2-1],S[R]-cnt,S[N-1]-S[R]]
res=min(res,max(ans)-min(ans),max(ans2)-min(ans2))
if R2!=N:
ans3=[S[L],cnt-S[L],S[R2-1]-cnt,S[N-1]-S[R2-1]]
ans4=[S[L2-1],cnt-S[L2-1],S[R2-1]-cnt,S[N-1]-S[R2-1]]
res=min(res,max(ans3)-min(ans3),max(ans4)-min(ans4))
return res
res=10**10
for i in range(N):
a=solve(i)
res=min(res,a)
print(res) | from itertools import accumulate
import bisect
N=int(eval(input()))
A=[int(x) for x in input().split()]
S=list(accumulate(A))
def solve(x):
cnt=S[x]
L=bisect.bisect_left(S,cnt/2)
R=bisect.bisect_left(S,(cnt+S[N-1])/2)
L2=L-1
R2=R-1
res=10**10
if R < N:
ans=[S[L],cnt-S[L],S[R]-cnt,S[N-1]-S[R]]
ans2=[S[L2],cnt-S[L2],S[R]-cnt,S[N-1]-S[R]]
res=min(res,max(ans)-min(ans),max(ans2)-min(ans2))
if R2 < N:
ans3=[S[L],cnt-S[L],S[R2]-cnt,S[N-1]-S[R2]]
ans4=[S[L2],cnt-S[L2],S[R2]-cnt,S[N-1]-S[R2]]
res=min(res,max(ans3)-min(ans3),max(ans4)-min(ans4))
return res
res=10**10
for i in range(N):
a=solve(i)
res=min(res,a)
print(res) | p03310 |
def solve():
N = int(eval(input()))
A = tuple(map(int, input().split()))
from itertools import accumulate
CA = list(accumulate(A))
mindiff = CA[-1]
for c in range(1,N-2):
# left side
p = 0
q = CA[-1]
left = 0
# for i in range(0, c):
while True:
pi = CA[left]
qi = CA[c] - CA[left]
if abs(pi- qi) >= abs(p - q):
break
p = pi; q = qi
left += 1
# right side
r = 0
s = CA[-1]
right = c+1
# for i in range(c+1, N):
while True:
ri = CA[right] - CA[c]
si = CA[-1] - CA[right]
if abs(ri- si) >= abs(r - s):
break
r = ri; s = si
right += 1
mindiff = min(mindiff, max(p, q, r, s) - min(p, q, r, s))
return mindiff
print((solve())) | N = int(eval(input()))
A = tuple(map(int, input().split()))
from itertools import accumulate
CA = list(accumulate(A))
mindiff = CA[-1]
left = 0
right = 2
for c in range(1,N-1):
# left side
p = CA[left]
q = CA[c] - CA[left]
while True:
pi = CA[left+1]
qi = CA[c] - CA[left+1]
if abs(pi- qi) >= abs(p - q):
break
p = pi; q = qi
left += 1
# right side
r = CA[right] - CA[c]
s = CA[-1] - CA[right]
while True:
ri = CA[right+1] - CA[c]
si = CA[-1] - CA[right+1]
if abs(ri- si) >= abs(r - s):
break
r = ri; s = si
right += 1
mindiff = min(mindiff, max(p, q, r, s) - min(p, q, r, s))
print(mindiff) | p03310 |
N = int(eval(input()))
A = list(map(int, input().split()))
S = [0] * (N+1)
for i in range(N) :
S[i+1] = S[i] + A[i]
leftMiddle = 0
rightMiddle = 2
ans = float('inf')
for middle in range(2, N-1) :
leftS = S[leftMiddle]
rightS = S[middle] - leftS
diff = abs(leftS - rightS)
# 左側の更新
for i in range(leftMiddle, middle) :
leftS += A[i]
rightS -= A[i]
if diff > abs(leftS - rightS) :
leftMiddle += 1
diff = abs(leftS - rightS)
else :
break
leftS = S[rightMiddle] - S[middle]
rightS = S[-1] - S[rightMiddle]
diff = abs(leftS - rightS)
# 右側の更新
for i in range(rightMiddle, N) :
leftS += A[i]
rightS -= A[i]
if diff > abs(leftS - rightS) :
rightMiddle += 1
diff = abs(leftS - rightS)
else :
break
B = S[leftMiddle]
C = S[middle] - B
D = S[rightMiddle] - S[middle]
E = S[-1] - B - C - D
diff = max(B, C, D, E) - min(B, C, D, E)
ans = min(ans, diff)
print(ans)
| N = int(eval(input()))
A = tuple(map(int, input().split()))
def calc(B):
P, Q = B[0], B[1]
ret = [None] * N
ret[1] = (P, Q)
mid = 1
for right in range(2, N - 2):
Q += B[right]
while mid < right:
newP = P + B[mid]
newQ = Q - B[mid]
if abs(newP - newQ) >= abs(P - Q):
break
mid += 1
P = newP
Q = newQ
ret[right] = (P, Q)
return ret
left = calc(A)[1: -2]
right = calc(A[:: -1])[1: -2][:: -1]
ans = 10**10
for (P, Q), (R, S) in zip(left, right):
ans = min(ans, abs(max(P, Q, R, S) - min(P, Q, R, S)))
print(ans)
| p03310 |
N = int(eval(input()))
A = [int(a) for a in input().split()]
def found_cut(X):
p1 = sum(X)/2
count1 = 0
for i in range(len(X)):
count1 += X[i]
if p1 <= count1:
if abs(count1-p1) < abs(count1-X[i]-p1):
index = i
break
else:
index = i-1
break
return index
def found_ans(X,Y,Z,W):
ans_list = []
ans_list.append(sum(X))
ans_list.append(sum(Y))
ans_list.append(sum(Z))
ans_list.append(sum(W))
return max(ans_list)-min(ans_list)
ANS = []
for x in range(1,N-2):
A_first = A[:x+1]
A_second = A[x+1:]
if len(A_first) >= 2 and len(A_second) >= 2:
wp1 = found_cut(A_first)
wp2 = found_cut(A_second)
pattern3_1 = A_first[:wp1+1]
pattern3_2 = A_first[wp1+1:]
pattern3_3 = A_second[:wp2+1]
pattern3_4 = A_second[wp2+1:]
ANS.append(found_ans(pattern3_1,pattern3_2,pattern3_3,pattern3_4))
print((min(ANS))) | N = int(eval(input()))
A = [int(a) for a in input().split()]
S = [0]*N
S[0] = A[0]
for i in range(1, N):
S[i] = A[i]+S[i-1]
ans = 2*10**14
l = 0
temp = 2*10**14
r = 2
#for i in range(2, N):
# if abs(S[-1]-2*S[i]+S[1]) < temp:
# temp = abs(S[-1]-2*S[r]+S[1])
# r = i
for i in range(2, N-1):
r = max(r, i)
while l+1 < i-1 and abs(S[i-1]-2*S[l]) > abs(S[i-1]-2*S[l+1]):
l += 1
while r+1 < N-1 and abs(S[N-1]-2*S[r]+S[i-1]) > abs(S[N-1]-2*S[r+1]+S[i-1]):
r += 1
t = max(S[N-1]-S[r], S[r]-S[i-1], S[i-1]-S[l], S[l]) - min(S[N-1]-S[r], S[r]-S[i-1], S[i-1]-S[l], S[l])
ans = min(ans, t)
print(ans) | p03310 |
from bisect import bisect_left
N = int(eval(input()))
A = [int(i) for i in input().split()]
s = sum(A)
for i in range(1, N) :
A[i] += A[i-1]
def check(d) :
ifr = bisect_left(A, (s - 3 * d) // 4)
ito = bisect_left(A, (s + 3 * d) // 4)
for i in range(ifr, min(N, ito + 1)) :
jfr = bisect_left(A, A[i] + (s - A[i] - 2 * d) // 3)
jto = bisect_left(A, A[i] + (s - A[i] + 2 * d) // 3)
for j in range(max(i + 1, jfr), min(N, jto + 1)) :
kfr = bisect_left(A, A[j] + (s - A[j] - d) // 2)
kto = bisect_left(A, A[j] + (s - A[j] + d) // 2)
for k in range(max(j + 1, kfr), min(N - 1, kto + 1)) :
cut = [A[i], A[j] - A[i], A[k] - A[j], s - A[k]]
if max(cut) - min(cut) <= d :
return True
return False
ng, ok = 0, s
while ok - ng > 1 :
mid = (ng + ok) // 2
if check(mid) :
ok = mid
else :
ng = mid
print(ok) | from bisect import bisect_left
N = int(eval(input()))
A = [int(i) for i in input().split()]
s = sum(A)
for i in range(1, N) :
A[i] += A[i-1]
ret = float('inf')
for b in range(1, N - 1) :
a = bisect_left(A, A[b] / 2)
c = bisect_left(A, A[b] + (s - A[b]) / 2)
for i in [a - 1, a] :
for j in [c - 1, c] :
if not 0 <= i < b < j < N - 1 :
continue
cut = [A[i], A[b] - A[i], A[j] - A[b], s - A[j]]
ret = min(ret, max(cut) - min(cut))
print(ret) | p03310 |
N = int(eval(input()))
A = list(map(int, input().split()))
arrSum = list(sum(A[:idx+1]) for idx in range(N))
ans = float('inf')
##2分する区切り目の左のインデックスi: 1 ～ (N - 3)
nextJ, nextK = -1, -1
for i in range(1, (N - 3) + 1):
##左側の区間の右端はi番目まである
##区切り目の左のインデックスj: 0 ～ (i - 1)
buf = float('inf')
nextJ = max(nextJ, 0)
for j in range(nextJ, i):
sumB = arrSum[j]
sumC = arrSum[i] - arrSum[j]
d = abs(sumB - sumC)
if buf > d:
buf = d
P = sumB
Q = sumC
nextJ = j
else:
break
##右側の区間の左端は(i + 1)番目
##区切り目の左のインデックスk: (i + 1) ～ (N - 2)
buf = float('inf')
nextK = max(nextK, (i + 1))
for k in range(nextK, (N - 2) + 1):
sumD = arrSum[k] - arrSum[i]
sumE = arrSum[N-1] - arrSum[k]
d = abs(sumD - sumE)
if buf > d:
buf = d
R = sumD
S = sumE
nextK = k
else:
break
arr = list((P, Q, R, S))
ans = min(ans, max(arr) - min(arr))
print(ans) | ##https://beta.atcoder.jp/contests/abc102/submissions/2779056
n = int(eval(input()))
a = list(map(int, input().split()))
s = [a[0]]
for i in range(n-1):
s.append(s[i] + a[i+1])
ans = s[n-1]
##i,j,kは左側の区間の右端
##iは1からN-3まで
j = 0
k = 2
for i in range(1, (n - 3) + 1):
##BC(i)DE
##BCの区間[0, i]: 最低でも2要素→0,1を取るのでi=1から
##DEの区間[i+1, N-1]: 最低でも2要素→N-2, N-1を取るので、i+1=N-2よりi=N-3まで
##B(j)C(i)DE
#Bの区間[0, j]
#Cの区間[j+1, i]
##sumB = s[j]
##sumC = s[i] - s[j]
while abs(s[i] - 2 * s[j]) > abs(s[i] - 2 * s[j+1]):
j += 1
##B(j)C(i)D(k)E
#Dの区間[i+1, k]
#Eの区間[k+1, N-1]
##sumD = s[k] - s[i]
##sumE = s[N-1] - s[k]
while abs(s[n-1] - 2 * s[k] + s[i]) > abs(s[n-1] - 2 * s[k+1] + s[i]):
k += 1
pqrs = list((s[j],s[i]-s[j],s[k]-s[i],s[n-1]-s[k]))
ans = min(ans, max(pqrs) - min(pqrs))
print(ans) | p03310 |
def get_num_f(data, sum_data):
left1, left2 = 0, sum_data
for i in range(len(data)- 1):
if left1 + data[i] >= left2 - data[i]:
pre_d = abs(left1 - left2)
now_d = abs((left1 + data[i]) - (left2 - data[i]))
if now_d < pre_d:
left1 += data[i]
left2 -= data[i]
break
left1 += data[i]
left2 -= data[i]
return left1, left2
def main():
num = int(eval(input()))
data = list(map(int, input().split()))
sum_left, sum_righ = sum(data[:2]), sum(data[2:])
left1, left2 = get_num_f(data[:2], sum_left)
righ1, righ2 = get_num_f(data[2:], sum_righ)
ans = max(left1, left2, righ1, righ2) - min(left1, left2, righ1, righ2)
for i in range(2, num - 2):
sum_left += data[i]
sum_righ -= data[i]
left1, left2 = get_num_f(data[:i + 1], sum_left)
righ1, righ2 = get_num_f(data[i + 1:], sum_righ)
ans_kari = max(left1, left2, righ1, righ2) - min(left1, left2, righ1, righ2)
if ans_kari < ans:
ans = ans_kari
print(ans)
if __name__ == '__main__':
main() |
def main():
num = int(eval(input()))
data = list(map(int, input().split()))
l, c, r = 1, 2, 3
P = sum(data[:l])
Q = sum(data[l:c])
R = sum(data[c:r])
S = sum(data[r:])
ans = max(P, Q, R, S) - min(P, Q, R, S)
while c <= num-2:
while True:
if abs(P-Q) < abs((P+data[l])-(Q-data[l])):
break
if l == c-1:
break
P += data[l]
Q -= data[l]
l += 1
while True:
if abs(R-S) < abs((R+data[r])-(S-data[r])):
break
if r == num-1:
break
R += data[r]
S -= data[r]
r += 1
ans = min(max(P,Q,R,S)- min(P,Q,R,S), ans)
# centerについて調整
Q += data[c]
R -= data[c]
c += 1
print(ans)
if __name__ == '__main__':
main()
| p03310 |
# -*- coding: utf-8 -*-
from itertools import combinations
n = int(eval(input()))
a = [int(_) for _ in input().split()]
combs = combinations(list(range(1, n)), 3)
grief = 10**10
for comb in combs:
p = sum(a[:comb[0]])
q = sum(a[comb[0]:comb[1]])
r = sum(a[comb[1]:comb[2]])
s = sum(a[comb[2]:])
tmp = max(p, q, r, s) - min(p, q, r, s)
if tmp < grief:
grief = tmp
print(grief)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
a = [int(_) for _ in input().split()]
# my initial trial below ##############################
# from itertools import combinations
# combs = combinations(range(1, n), 3)
# grief = 10**10
# for comb in combs:
# p = sum(a[:comb[0]])
# q = sum(a[comb[0]:comb[1]])
# r = sum(a[comb[1]:comb[2]])
# s = sum(a[comb[2]:])
# tmp = max(p, q, r, s) - min(p, q, r, s)
# if tmp < grief:
# grief = tmp
# print(grief) # running time limit error
# solution below ######################################
cumul_sum = [0]
for i, ai in enumerate(a):
cumul_sum.append(ai + cumul_sum[i])
def cal_sum(left, right):
return cumul_sum[right] - cumul_sum[left]
def two_pointers(l, r, split, diff):
for i in range(split, r):
tmp_diff = abs(cal_sum(l, i) - cal_sum(i, r))
if diff >= tmp_diff:
diff = tmp_diff
else:
return i - 1, diff
else:
return r - 1, diff
l_split = 1
r_split = 3
griefs = []
for i in range(2, n - 1):
# left
l_split, l_diff = two_pointers(0, i, l_split, 10**12)
# right
r_split, r_diff = two_pointers(i, n, r_split, 10**12)
p, q, r, s = cal_sum(0, l_split), cal_sum(l_split,
i), cal_sum(i, r_split), cal_sum(
r_split, n)
griefs.append(max(p, q, r, s) - min(p, q, r, s))
print((min(griefs)))
| p03310 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
a = [int(_) for _ in input().split()]
# my initial trial below ##############################
# from itertools import combinations
# INF = 10 ** 15
# combs = combinations(range(1, n), 3)
# grief = INF
# for comb in combs:
# p = sum(a[:comb[0]])
# q = sum(a[comb[0]:comb[1]])
# r = sum(a[comb[1]:comb[2]])
# s = sum(a[comb[2]:])
# tmp = max(p, q, r, s) - min(p, q, r, s)
# if tmp < grief:
# grief = tmp
# print(grief) # running time limit error
# solution below ######################################
INF = 10**15
cumul_sum = [0]
for i, ai in enumerate(a):
cumul_sum.append(ai + cumul_sum[i])
def cal_sum(left, right):
return cumul_sum[right] - cumul_sum[left]
def two_pointers(l, r, split, diff):
left_sum = cal_sum(l, split)
right_sum = cal_sum(split, r)
diff = abs(left_sum - right_sum)
for i in range(split, r):
tmp_left_sum = cal_sum(l, i)
tmp_right_sum = cal_sum(i, r)
tmp_diff = abs(tmp_left_sum - tmp_right_sum)
if diff >= tmp_diff:
left_sum = tmp_left_sum
right_sum = tmp_right_sum
diff = tmp_diff
else:
return i - 1, diff, left_sum, right_sum
else:
return r - 1, tmp_diff, tmp_left_sum, tmp_right_sum
l_split = 1
r_split = 3
griefs = []
for i in range(2, n - 1):
# left
l_split, l_diff, p, q = two_pointers(0, i, l_split, INF)
# right
r_split, r_diff, r, s = two_pointers(i, n, r_split, INF)
griefs.append(max(p, q, r, s) - min(p, q, r, s))
print((min(griefs)))
| # -*- coding: utf-8 -*-
n = int(eval(input()))
a = [int(_) for _ in input().split()]
# my initial attempt below ############################
# from itertools import combinations
# INF = 10 ** 15
# combs = combinations(range(1, n), 3)
# grief = INF
# for comb in combs:
# p = sum(a[:comb[0]])
# q = sum(a[comb[0]:comb[1]])
# r = sum(a[comb[1]:comb[2]])
# s = sum(a[comb[2]:])
# tmp = max(p, q, r, s) - min(p, q, r, s)
# if tmp < grief:
# grief = tmp
# print(grief) # running time limit error
# solution below ######################################
cumul_sum = [0]
for i, ai in enumerate(a):
cumul_sum.append(ai + cumul_sum[i])
def cal_sum(left, right):
return cumul_sum[right] - cumul_sum[left]
def two_pointers(l, r, split):
left_sum = cal_sum(l, split)
right_sum = cal_sum(split, r)
diff = abs(left_sum - right_sum)
for i in range(split, r):
tmp_left_sum = cal_sum(l, i)
tmp_right_sum = cal_sum(i, r)
tmp_diff = abs(tmp_left_sum - tmp_right_sum)
if diff >= tmp_diff:
left_sum = tmp_left_sum
right_sum = tmp_right_sum
diff = tmp_diff
else:
return i - 1, diff, left_sum, right_sum
else:
return r - 1, tmp_diff, tmp_left_sum, tmp_right_sum
l_split = 1
r_split = 3
griefs = []
for i in range(2, n - 1):
# left
l_split, l_diff, p, q = two_pointers(0, i, l_split)
# right
r_split, r_diff, r, s = two_pointers(i, n, r_split)
griefs.append(max(p, q, r, s) - min(p, q, r, s))
print((min(griefs)))
| p03310 |
# -*- coding: utf-8 -*-
def two_pointers(ary, l, r, split, ary_func, comb_func, comp_func):
'''
This function is supposed to be repeatedly called so that 'split' keeps
renewing, under an assumption that 'split' increases monotonously.
('l' and 'r' just specify the region to be searched in 'ary')
'''
left = ary_func(ary, l, split)
right = ary_func(ary, split, r)
val = comb_func(left, right)
for i in range(split + 1, r):
tmp_left = ary_func(ary, l, i)
tmp_right = ary_func(ary, i, r)
tmp_val = comb_func(tmp_left, tmp_right)
if comp_func(val, tmp_val):
return i - 1, val, left, right
else:
left = tmp_left
right = tmp_right
val = tmp_val
else:
return r - 1, val, left, right
if __name__ == '__main__':
from operator import add
from itertools import accumulate
n = int(eval(input()))
a = [int(_) for _ in input().split()]
cul_ary = [0] + list(accumulate(a, add))
l_split = 1
r_split = 3
griefs = []
for i in range(2, n - 1):
# left
l_split, l_diff, p, q = two_pointers(cul_ary,
0,
i,
l_split,
lambda ary, l, r: ary[r] - ary[l],
lambda left, right: abs(left - right),
lambda val1, val2: True if val1 < val2 else False)
# right
r_split, r_diff, r, s = two_pointers(cul_ary,
i,
n,
r_split,
lambda ary, l, r: ary[r] - ary[l],
lambda left, right: abs(left - right),
lambda val1, val2: True if val1 < val2 else False)
griefs.append(max(p, q, r, s) - min(p, q, r, s))
print((min(griefs)))
| # -*- coding: utf-8 -*-
def two_pointers(ary, l, r, split, ary_func, comb_func, comp_func):
'''
This function is supposed to be repeatedly called so that 'split' keeps
renewing, under an assumption that 'split' increases monotonously.
('l' and 'r' just specify the region to be searched in 'ary')
'''
left = ary_func(ary, l, split)
right = ary_func(ary, split, r)
val = comb_func(left, right)
for i in range(split + 1, r):
tmp_left = ary_func(ary, l, i)
tmp_right = ary_func(ary, i, r)
tmp_val = comb_func(tmp_left, tmp_right)
if comp_func(val, tmp_val):
return i - 1, val, left, right
else:
left = tmp_left
right = tmp_right
val = tmp_val
else:
return r - 1, val, left, right
if __name__ == '__main__':
'''
an example of using this function
At-Coder ABC 102 - D
'''
from operator import add
from itertools import accumulate
n = int(eval(input()))
a = [int(_) for _ in input().split()]
cul_ary = [0] + list(accumulate(a, add))
l_split = 1
r_split = 3
funcs = (lambda ary, l, r: ary[r] - ary[l],
lambda left, right: abs(left - right),
lambda val1, val2: True if val1 < val2 else False)
griefs = []
for i in range(2, n - 1):
# left
l_split, l_diff, p, q = two_pointers(cul_ary, 0, i, l_split, *funcs)
# right
r_split, r_diff, r, s = two_pointers(cul_ary, i, n, r_split, *funcs)
griefs.append(max(p, q, r, s) - min(p, q, r, s))
print((min(griefs)))
| p03310 |
from itertools import accumulate
from bisect import bisect_left
N, *A = list(map(int, open(0).read().split()))
A = [0] + list(accumulate(A))
ans = float("inf")
for i in range(2, N - 1):
lm = A[i] // 2
l = bisect_left(A, lm)
if abs(A[l - 1] - lm) < abs(A[l] - lm):
l -= 1
rm = (A[i] + A[N]) // 2
r = bisect_left(A, rm)
if abs(A[r - 1] - rm) < abs(A[r] - rm):
r -= 1
P = A[l]
Q = A[i] - A[l]
R = A[r] - A[i]
S = A[N] - A[r]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
| from itertools import accumulate
from bisect import bisect_left
def main():
N, *A = list(map(int, open(0).read().split()))
A = [0] + list(accumulate(A))
ans = float("inf")
for i in range(2, N - 1):
lm = A[i] // 2
l = bisect_left(A, lm)
if abs(A[l - 1] - lm) < abs(A[l] - lm):
l -= 1
rm = (A[i] + A[N]) // 2
r = bisect_left(A, rm)
if abs(A[r - 1] - rm) < abs(A[r] - rm):
r -= 1
P = A[l]
Q = A[i] - A[l]
R = A[r] - A[i]
S = A[N] - A[r]
ans = min(ans, max(P, Q, R, S) - min(P, Q, R, S))
print(ans)
main()
| p03310 |
N = int(eval(input()))
A = [int(x) for x in input().split()]
SUM = [0] * N
SUM[0] = A[0]
for i in range(1, N):
SUM[i] = SUM[i - 1] + A[i]
left_min = right_min = ans = float('INF')
left_max = right_max = 0
for r in range(2, N - 1):
# 左のしゃくとり
P, Q = P2, Q2 = -1, -1
p = 0
q = 1
while True:
P2, Q2 = P, Q
P = SUM[q - 1]
Q = SUM[r - 1] - SUM[q - 1]
if P < Q and q < r:
q += 1
else:
break
left_min, left_max = min(P, Q), max(P, Q)
if P2 != -1:
if abs(Q - P) > abs(Q2 - P2):
left_min, left_max = min(P2, Q2), max(P2, Q2)
# 右のしゃくとり
R, S = R2, S2 = -1, -1
s = r + 1
while True:
R2, S2 = R, S
R = SUM[s - 1] - SUM[r - 1]
S = SUM[N - 1] - SUM[s - 1]
if R < S and s < N - 1:
s += 1
else:
break
right_min, right_max = min(R, S), max(R, S)
if R2 != -1:
if abs(R - S) > abs(R2 - S2):
right_min, right_max = min(R2, S2), max(R2, S2)
# print(p, q, r, s)
# print(P, Q, R, S)
# print(P2, Q2, R2, S2)
# print("----------")
ans = min(max(left_max, right_max) - min(left_min, right_min), ans)
print(ans)
| N = int(eval(input()))
A = [int(x) for x in input().split()]
SUM = [0] * N
SUM[0] = A[0]
for i in range(1, N):
SUM[i] = SUM[i - 1] + A[i]
left_min = right_min = ans = float('INF')
left_max = right_max = 0
p = 0
q = 1
r = N // 2
s = r + 1
for r in range(2, N - 1):
# 左
P1, Q1 = P2, Q2 = -1, -1
low, high = 1, r - 1
while low + 1 < high:
mid = (low + high) // 2
P = SUM[mid - 1]
Q = SUM[r - 1] - SUM[mid - 1]
if P < Q:
low = mid
else:
high = mid
P1, Q1 = SUM[low - 1], SUM[r - 1] - SUM[low - 1]
P2, Q2 = SUM[high - 1], SUM[r - 1] - SUM[high - 1]
left_min, left_max = min(P1, Q1), max(P1, Q1)
if abs(Q1 - P1) > abs(Q2 - P2):
left_min, left_max = min(P2, Q2), max(P2, Q2)
# 右
R1, S1 = R2, S2 = -1, -1
low, high = r + 1, N - 1
while low + 1 < high:
mid = (low + high) // 2
R = SUM[mid - 1] - SUM[r - 1]
S = SUM[N - 1] - SUM[mid - 1]
if R < S:
low = mid
else:
high = mid
R1, S1 = SUM[low - 1] - SUM[r - 1], SUM[N - 1] - SUM[low - 1]
R2, S2 = SUM[high - 1] - SUM[r - 1], SUM[N - 1] - SUM[high - 1]
right_min, right_max = min(R1, S1), max(R1, S1)
if abs(R1 - S1) > abs(R2 - S2):
right_min, right_max = min(R2, S2), max(R2, S2)
# print(P1, Q1, R1, S1, sum([P1, Q1, R1, S1]), sum(A))
# print(P2, Q2, R2, S2, sum([P2, Q2, R2, S2]), sum(A))
# print("--------")
ans = min(max(left_max, right_max) - min(left_min, right_min), ans)
print(ans)
| p03310 |
#102_D
N = int(eval(input()))
A = [int(i) for i in input().split()]
s = 0
AS = []
for i in range(N):
s += A[i]
AS.append(s)
#尺取り法
Ans = AS[N-1]+1
L = 0
R = 2
for Mid in range(1, N-2):
Sum_L = AS[Mid]
Sum_R = AS[N-1]-Sum_L
while abs((Sum_L - AS[L]) - AS[L]) > abs((Sum_L - AS[L+1]) - AS[L+1]):
L += 1
while abs((AS[N-1]-AS[R]) - (AS[R]-Sum_L)) > abs((AS[N-1]-AS[R+1]) - (AS[R+1]-Sum_L)):
R += 1
P = AS[L]
Q = Sum_L-AS[L]
S = AS[R]-Sum_L
T = AS[N-1]-AS[R]
#print(Mid,L,R,abs(max(P,Q,S,T)-min(P,Q,S,T)))
Ans = min(Ans, abs(max(P, Q, S, T)-min(P, Q, S, T)))
print(Ans)
| N = int(eval(input()))
A_list = [int(i) for i in input().split()]
Total_list = []
s = 0
for num in A_list:
s += num
Total_list.append(s)
L = 0
R = 2
ans = Total_list[N-1]+1
for Mid in range(1, N-2):
sum_L = Total_list[Mid]
sum_R = Total_list[N-1] - sum_L
while abs(sum_L - 2*Total_list[L]) > abs(sum_L - 2*Total_list[L+1]):
L += 1
while abs((Total_list[N-1]-Total_list[R])-(Total_list[R] - sum_L)) > abs((Total_list[N-1]-Total_list[R+1])-(Total_list[R+1] - sum_L)):
R += 1
P = Total_list[L]
Q = sum_L - Total_list[L]
S = Total_list[R] - sum_L
T = Total_list[N-1] - Total_list[R]
ans = min(ans, max(P, Q, S, T) - min(P, Q, S, T))
print(ans)
| p03310 |
from itertools import *
n=int(eval(input()))
sumA=[0]+list(accumulate(list(map(int,input().split()))))
def check(l,m,r):
if m==r:return False
tmp=sumA[r]+sumA[l]
return abs(tmp-sumA[m+1]*2)<abs(tmp-sumA[m]*2)
res=float('inf')
li,ri=1,3
for mid in range(2,n-1):
while check(0,li,mid):li+=1
while check(mid,ri,n):ri+=1
x=sorted([sumA[li],sumA[mid]-sumA[li],sumA[ri]-sumA[mid],sumA[n]-sumA[ri]])
tmp=x[3]-x[0]
if tmp<res:res=tmp
print(res) | from itertools import *
eval(input())
s=list(accumulate(list(map(int,input().split()))))
l,r,t=0,2,s[-1];a=t
for m in s[1:-2]:
while abs(t-2*s[r]+m)>abs(t-2*s[r+1]+m):r+=1
while abs(m-2*s[l])>abs(m-2*s[l+1]):l+=1
x=sorted([s[l],m-s[l],s[r]-m,t-s[r]])
a=min(a,x[3]-x[0])
print(a) | p03310 |
def run(n, a):
sum_a = [sum(a[0:i+1]) for i in range(n)]
ret = sum_a[n - 1]
for i in range(2, n-1):
j_l = search_j(sum_a[: i], 0)
j_r = search_j(sum_a[i:], sum_a[i - 1]) + i
p = sum_a[j_l]
q = sum_a[i - 1] - p
r = sum_a[j_r] - q - p
s = sum_a[n - 1] - r - q - p
diff = max(p, q, r, s) - min(p, q, r, s)
if ret > diff:
ret = diff
return ret
def search_j(sum_a, before):
n = len(sum_a)
sum_l = sum_a[0] - before
sum_r = sum_a[n - 1] - sum_a[0]
diff1 = sum_r - sum_l
ret = 0
for i in range(n - 1):
sum_l = sum_a[i] - before
sum_r = sum_a[n - 1] - sum_a[i]
diff2 = sum_r - sum_l
if diff2 < 0:
if abs(diff1) < abs(diff2):
return i - 1
else:
return i
else:
diff1 = diff2
ret = i
return ret
def read_line():
n = int(eval(input()))
a = list(map(int, input().split()))
return (n, a)
def main():
n, a = read_line()
print((run(n, a)))
if __name__ == '__main__':
main()
| from itertools import accumulate
def run(n, a):
# sum_a = [sum(a[0:i+1]) for i in range(n)]
sum_a = list(accumulate(a))
li = 0
ri = 2
t = sum_a[-1]
diff = sum_a[-1]
# 真ん中の切れ込みを順に変更
# 左の切れ込みの位置はiに対して単調増加
# 左の切れ込みで真ん中の項を移動するかどうかは、
# 真ん中の項を除いて、小さい方に入れる
# ただし単調増加なので、左の切れ込みの左側が
# 小さいときに真ん中を左の切れ込みの左側に入れる
# 右も同様に考える
for i in range(1, n-2):
while sum_a[i] > sum_a[li+1] + sum_a[li]:
li += 1
while t + sum_a[i] > sum_a[ri+1] + sum_a[ri]:
ri += 1
p = sum_a[li]
q = sum_a[i] - p
r = sum_a[ri] - q - p
s = t - sum_a[ri]
diff = min(diff, max(p, q, r, s) - min(p, q, r, s))
return diff
def read_line():
n = int(eval(input()))
a = list(map(int, input().split()))
return (n, a)
def main():
n, a = read_line()
print((run(n, a)))
if __name__ == '__main__':
main()
| p03310 |
from collections import deque
import bisect
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0] * (n + 1)
for i in range(n):
b[i + 1] = b[i] + a[i]
l, r = deque([b[1]]), deque(b[3 : n])
lenl, lenr = len(l), len(r)
ans = 1145141919810
for i in range(2, n - 1):
cl, cr = b[i] / 2, (b[n] - b[i]) / 2
ml = bisect.bisect_left(l, cl)
mr = bisect.bisect_left(r, cr + b[i])
if ml == 0:
x = b[1]
elif ml == lenl:
x = l[-1]
else:
if l[ml] - cl <= cl - l[ml - 1]:
x = l[ml]
else:
x = l[ml - 1]
if mr == 0:
y = r[0]
elif mr == lenr:
y = b[-2]
else:
if r[mr] - (cr + b[i]) <= (cr + b[i]) - r[mr - 1]:
y = r[mr]
else:
y = r[mr - 1]
s = [x, b[i] - x, y - b[i], b[n] - y]
ans = min(ans, max(s) - min(s))
l.append(b[i])
r.popleft()
lenl += 1
lenr -= 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
b = [0] * (n + 1)
for i in range(n):
b[i + 1] = b[i] + a[i]
x = [[0, 0] for _ in range(n - 3)]
j = 1
for i in range(2, n - 1):
while True:
if i == j + 1:
x[i - 2][0] = b[j]
break
if abs(b[i] - 2 * b[j]) > abs(b[i] - 2 * b[j + 1]):
j += 1
else:
x[i - 2][0] = b[j]
break
j = n - 1
for i in range(n - 2, 1, -1):
while True:
if i == j - 1:
x[i - 2][1] = b[j]
break
if abs(b[n] + b[i] - 2 * b[j]) > abs(b[n] + b[i] - 2 * b[j - 1]):
j -= 1
else:
x[i - 2][1] = b[j]
break
ans = 1145141919810
for i in range(n - 3):
s = [x[i][0], b[i + 2] - x[i][0], x[i][1] - b[i + 2], b[n] - x[i][1]]
ans = min(ans, max(s) - min(s))
print(ans) | p03310 |
# 整数列A
# 3箇所で切って、４つに
# それぞれの総和の最大値と最小値の差の絶対値の最小値
# 中央を固定することを考える(結局、その固定を全検索するが)
# 中央固定後、左側について、両方が同じくらいの値になるのが最適と考えて良いらしい
from itertools import accumulate
N=int(eval(input()))
A=list(map(int,input().split()))
SumA=list(accumulate(A))
tmpP=tmpQ=tmpR=tmpS=0
P=Q=R=S=0
left = -1
ans=10e9
for mid in range(1,N-1):
diffL=10e9
diffR=10e9
for l in range(mid):
tmpP=SumA[l]
tmpQ=SumA[mid] - SumA[l]
if abs(tmpQ-tmpP) < diffL:
diffL = abs(tmpQ-tmpP)
left = l
P=tmpP
Q=tmpQ
for r in range(mid+1,N-1):
tmpR=SumA[r] - SumA[mid]
tmpS=SumA[N-1] - SumA[mid] - tmpR
if abs(tmpS-tmpR) < diffR:
diffR = abs(tmpS-tmpR)
right = r
R=tmpR
S=tmpS
# print(P,Q,R,S)
diff=max(P,Q,R,S)-min(P,Q,R,S)
diff=abs(diff)
ans = min(ans,diff)
print(ans)
| # 整数列A
# 3箇所で切って、４つに
# それぞれの総和の最大値と最小値の差の絶対値の最小値
# 中央を固定することを考える(結局、その固定を全検索するが)
# 中央固定後、左側について、両方が同じくらいの値になるのが最適と考えて良いらしい
from itertools import accumulate
N=int(eval(input()))
A=list(map(int,input().split()))
SumA=list(accumulate(A))
tmpP=tmpQ=tmpR=tmpS=0
P=Q=R=S=0
ans=10e9
l = 0
r = 2
# midとmid+1の間が中間の切断
for mid in range(1,N-2):
# l,rは、単調増加であるため、全ての中間点を求めるループの間、クリアの必要がないらしい
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while l < mid and abs(SumA[l+1]-(SumA[mid] - SumA[l+1])) < abs(SumA[l]-(SumA[mid] - SumA[l])):
l += 1
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while r <= mid or (r < N and abs((SumA[r+1]-SumA[mid]) - (SumA[N-1]-SumA[r+1])) < abs((SumA[r] - SumA[mid]) - (SumA[N-1] - SumA[r]))):
r += 1
#print("{},{}".format(mid,l))
P=SumA[l]
Q=SumA[mid]-SumA[l]
R=SumA[r]-SumA[mid]
S=SumA[N-1]-SumA[r]
#print(P,Q,R,S)
diff=max(P,Q,R,S)-min(P,Q,R,S)
diff=abs(diff)
ans = min(ans,diff)
print(ans)
| p03310 |
# 整数列A
# 3箇所で切って、４つに
# それぞれの総和の最大値と最小値の差の絶対値の最小値
# 中央を固定することを考える(結局、その固定を全検索するが)
# 中央固定後、左側について、両方が同じくらいの値になるのが最適と考えて良いらしい
from itertools import accumulate
N=int(eval(input()))
A=list(map(int,input().split()))
SumA=list(accumulate(A))
tmpP=tmpQ=tmpR=tmpS=0
P=Q=R=S=0
ans=10e9
l = 0
r = 2
# midとmid+1の間が中間の切断
for mid in range(1,N-2):
# l,rは、単調増加であるため、全ての中間点を求めるループの間、クリアの必要がないらしい
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while l < mid and abs(SumA[l+1]-(SumA[mid] - SumA[l+1])) < abs(SumA[l]-(SumA[mid] - SumA[l])):
l += 1
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while r <= mid or (r < N and abs((SumA[r+1]-SumA[mid]) - (SumA[N-1]-SumA[r+1])) < abs((SumA[r] - SumA[mid]) - (SumA[N-1] - SumA[r]))):
r += 1
#print("{},{}".format(mid,l))
P=SumA[l]
Q=SumA[mid]-SumA[l]
R=SumA[r]-SumA[mid]
S=SumA[N-1]-SumA[r]
#print(P,Q,R,S)
diff=max(P,Q,R,S)-min(P,Q,R,S)
diff=abs(diff)
ans = min(ans,diff)
print(ans)
| # 整数列A
# 3箇所で切って、４つに
# それぞれの総和の最大値と最小値の差の絶対値の最小値
# 中央を固定することを考える(結局、その固定を全検索するが)
# 中央固定後、左側について、両方が同じくらいの値になるのが最適と考えて良いらしい
from itertools import accumulate
N=int(eval(input()))
A=list(map(int,input().split()))
SumA=list(accumulate(A))
tmpP=tmpQ=tmpR=tmpS=0
P=Q=R=S=0
ans=10e9
l = 0
r = 2
# midとmid+1の間が中間の切断
for mid in range(1,N-2):
# l,rは、単調増加であるため、全ての中間点を求めるループの間、クリアの必要がないらしい
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while l < mid and abs((SumA[mid] - SumA[l+1])-SumA[l+1]) < abs((SumA[mid] - SumA[l])-SumA[l]):
l += 1
# 次のやつよりも、今のやつの方が大きい限り、継続
# 必ず、それが逆転する時が最小のはず、という考え。。。
while r < N-1 and abs((SumA[N-1]-SumA[r+1])-(SumA[r+1]-SumA[mid])) < abs((SumA[N-1] - SumA[r])-(SumA[r] - SumA[mid])):
r += 1
#print("{},{}".format(mid,l))
P=SumA[l]
Q=SumA[mid]-SumA[l]
R=SumA[r]-SumA[mid]
S=SumA[N-1]-SumA[r]
#print(P,Q,R,S)
diff=max(P,Q,R,S)-min(P,Q,R,S)
diff=abs(diff)
ans = min(ans,diff)
print(ans)
| p03310 |
N=int(eval(input()))
A=list(map(int,input().split()))
cut_1=1
cut_2=2
cut_3=3
A_0=A[:cut_1]
S_0=sum(A_0)
A_1=A[cut_1:cut_2]
S_1=sum(A_1)
A_2=A[cut_2:cut_3]
S_2=sum(A_2)
A_3=A[cut_3:]
S_3=sum(A_3)
def irekae(S,T,i):
if abs(S-T)>abs((S-A[i-1])-(T+A[i-1])):
S=S-A[i-1]
T=T+A[i-1]
i=i-1
elif abs(T-S)>abs((T-A[i])-(S+A[i])):
#print(T,S,T-S,i)
S=S+A[i]
T=T-A[i]
i=i+1
#print(T,S,T-S,i)
return (S,T,i)
MIN=[]
cut_1b=0
cut_3b=0
for cut_2 in range(2,N-1):
cut_1b=0
cut_3b=0
while cut_1b != cut_1:
cut_1b=cut_1
S_0,S_1,cut_1=irekae(S_0,S_1,cut_1)
#print(cut_1)
while cut_3b != cut_3:
cut_3b=cut_3
S_2,S_3,cut_3=irekae(S_2,S_3,cut_3)
MIN+=[max([S_0,S_1,S_2,S_3])-min([S_0,S_1,S_2,S_3])]
#print(cut_1,cut_2,cut_3,S_0,S_1,S_2,S_3)
S_1+=A[cut_2]
S_2-=A[cut_2]
print((min(MIN)))
| N=int(eval(input()))
A=list(map(int,input().split()))
SUM=[0]
for a in A:
SUM.append(SUM[-1]+a)
i=1
j=2
k=3
P=SUM[i]
Q=SUM[j]-SUM[i]
R=SUM[k]-SUM[j]
S=SUM[N]-SUM[k]
ANS=10**10
check=1
while j<N-1:
check=1
while check==1:
check=0
if i<j-1:
if abs(P-Q)>abs(P+A[i]-Q+A[i]):
P+=A[i]
Q-=A[i]
i+=1
check=1
if k<N-1:
if abs(R-S)>abs(R+A[k]-S+A[k]):
R+=A[k]
S-=A[k]
k+=1
check=1
#print(P,Q,R,S,i,j,k)
if ANS>max([P,Q,R,S])-min([P,Q,R,S]):
ANS=max([P,Q,R,S])-min([P,Q,R,S])
Q+=A[j]
R-=A[j]
j+=1
print(ANS) | p03310 |
# encoding: utf-8
import math
N = int(eval(input()))
A = list(map(int, input().split()))
def binsearch(seq, l, r, tar):
# print("##", l, r, LmR[l:r + 1], tar)
m = l + (r - l) // 2
if l >= r: return l
elif seq[m] < tar: return binsearch(seq, m + 1, r, tar)
else: return binsearch(seq, l, m, tar)
Asum = [0]
tmp = 0
for Ai in A:
tmp += Ai
Asum.append(tmp)
LmR = []
for SAi in Asum[:-1]:
LmR.append(-Asum[-1] + 2 * SAi)
# find b2 initial position (sub-optimal)
tar = 0
b2 = binsearch(LmR, 2, N - 2, tar)
if tar - LmR[b2 - 1] < LmR[b2] - tar: b2 = max((2, b2 - 1))
# b1
tar = -(Asum[N] - Asum[b2])
b1 = binsearch(LmR, 1, b2 - 1, tar)
if tar - LmR[b1 - 1] < LmR[b1] - tar: b1 = max((1, b1 - 1))
# b3
tar = Asum[b2]
b3 = binsearch(LmR, b2 + 1, N - 1, tar)
if tar - LmR[b3 - 1] < LmR[b3] - tar: b3 = max((b2 + 1, b3 - 1))
parts = (Asum[b1], Asum[b2] - Asum[b1], Asum[b3] - Asum[b2], Asum[-1] - Asum[b3])
ans = max(parts) - min(parts)
b2_init = b2
# sweep b2
for b2 in range(2, N - 1):
# escape
if b2 == b2_init: continue
elif LmR[b2] < -2 * ans: continue
elif LmR[b2] > 2 * ans: break
# b1
tar = -(Asum[N] - Asum[b2])
b1 = binsearch(LmR, 1, b2 - 1, tar)
if tar - LmR[b1 - 1] < LmR[b1] - tar: b1 = max((1, b1 - 1))
# escape
if math.fabs((Asum[b2] - Asum[b1]) - (Asum[b1])) >= ans: continue
# b3
tar = Asum[b2]
b3 = binsearch(LmR, b2 + 1, N - 1, tar)
if tar - LmR[b3 - 1] < LmR[b3] - tar: b3 = max((b2 + 1, b3 - 1))
parts = (Asum[b1], Asum[b2] - Asum[b1], Asum[b3] - Asum[b2], Asum[-1] - Asum[b3])
if max(parts) - min(parts) < ans: ans = max(parts) - min(parts)
print(ans) | # encoding: utf-8
import math
N = int(eval(input()))
A = list(map(int, input().split()))
def binsearch(seq, l, r, tar):
# print("##", l, r, LmR[l:r + 1], tar)
m = l + (r - l) // 2
if l >= r: return l
elif seq[m] < tar: return binsearch(seq, m + 1, r, tar)
else: return binsearch(seq, l, m, tar)
# sum(A[i:j]) == Asum[j] - Asum[i]
Asum = [0]
tmp = 0
for Ai in A:
tmp += Ai
Asum.append(tmp)
LmR = []
for SAi in Asum[:-1]:
LmR.append(-Asum[-1] + 2 * SAi)
b1, b3 = (1, 3)
parts = [A[0], A[1], A[2], Asum[N] - Asum[3]]
ans = max(parts) - min(parts)
for b2 in range(2, N - 1):
parts[1] -= A[b2]
parts[2] += A[b2]
if b3 == b2: b3 = b2 + 1
# b1
for btmp in range(b1, b2):
bfr = math.fabs((Asum[b2] - Asum[btmp]) - (Asum[btmp] - Asum[0]))
aft = math.fabs((Asum[b2] - Asum[btmp + 1]) - (Asum[btmp + 1] - Asum[0]))
if aft < bfr: continue
else: break
b1 = btmp
# b3
for btmp in range(b3, N):
bfr = math.fabs((Asum[N] - Asum[btmp]) - (Asum[btmp] - Asum[b2]))
aft = math.fabs((Asum[N] - Asum[btmp + 1]) - (Asum[btmp + 1] - Asum[b2]))
if aft < bfr: continue
else: break
b3 = btmp
# update
parts = [Asum[b1], Asum[b2] - Asum[b1], Asum[b3] - Asum[b2], Asum[N] - Asum[b3]]
if ans > max(parts) - min(parts): ans = max(parts) - min(parts)
print(ans)
# TLE
# # find b2 initial position (sub-optimal)
# tar = 0
# b2 = binsearch(LmR, 2, N - 2, tar)
# if tar - LmR[b2 - 1] < LmR[b2] - tar: b2 = max((2, b2 - 1))
# # b1
# tar = -(Asum[N] - Asum[b2])
# b1 = binsearch(LmR, 1, b2 - 1, tar)
# if tar - LmR[b1 - 1] < LmR[b1] - tar: b1 = max((1, b1 - 1))
# # b3
# tar = Asum[b2]
# b3 = binsearch(LmR, b2 + 1, N - 1, tar)
# if tar - LmR[b3 - 1] < LmR[b3] - tar: b3 = max((b2 + 1, b3 - 1))
# parts = (Asum[b1], Asum[b2] - Asum[b1], Asum[b3] - Asum[b2], Asum[-1] - Asum[b3])
# ans = max(parts) - min(parts)
# b2_init = b2
# # sweep b2
# for b2 in range(2, N - 1):
# # escape
# if b2 == b2_init: continue
# elif LmR[b2] < -2 * ans: continue
# elif LmR[b2] > 2 * ans: break
# # b1
# tar = -(Asum[N] - Asum[b2])
# b1 = binsearch(LmR, 1, b2 - 1, tar)
# if tar - LmR[b1 - 1] < LmR[b1] - tar: b1 = max((1, b1 - 1))
# # escape
# if math.fabs((Asum[b2] - Asum[b1]) - (Asum[b1])) >= ans: continue
# # b3
# tar = Asum[b2]
# b3 = binsearch(LmR, b2 + 1, N - 1, tar)
# if tar - LmR[b3 - 1] < LmR[b3] - tar: b3 = max((b2 + 1, b3 - 1))
# parts = (Asum[b1], Asum[b2] - Asum[b1], Asum[b3] - Asum[b2], Asum[-1] - Asum[b3])
# if max(parts) - min(parts) < ans: ans = max(parts) - min(parts)
# print(ans) | p03310 |
# coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def binary_search(A, x):
low = 0
high = len(A) - 1
mid = (low + high) // 2
while low <= high:
if A[mid] == x:
break
elif A[mid] < x:
low = mid + 1
else:
high = mid - 1
mid = (low + high) // 2
if mid < 0:
return 0
else:
return mid
N = int(eval(input()))
A = inpl()
B = A[:]
# 累積和
for i in range(1, N):
B[i] = B[i] + B[i - 1]
ans = INF
for mid in range(2, N - 1):
L = B[:mid]
R = B[mid:]
R = [R[i] - L[-1] for i in range(len(R))]
# print(L)
# print(R)
sum_list = []
for li in [L, R]:
if len(li) == 2: # R, Lの要素数が2の場合の分け方は1通り
sum_list.append(li[0])
sum_list.append(li[1] - li[0])
continue
# 真ん中の切れ込みが固定されている時のRとLの切れ込みの決定
mid = binary_search(li, li[-1] // 2)
diff1 = abs(2 * li[mid] - li[-1])
diff2 = abs(2 * li[mid + 1] - li[-1])
if diff1 < diff2:
sum_list.append(li[mid])
sum_list.append(li[-1] - li[mid])
else:
sum_list.append(li[mid + 1])
sum_list.append(li[-1] - li[mid + 1])
ans = min(ans, max(sum_list) - min(sum_list))
print(ans) | # coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
A = inpl()
B = A[:]
# 累積和
for i in range(1, N):
B[i] = B[i] + B[i - 1]
ans = INF
mid_l = 0
mid_r = 2
t = B[-1]
for mid in range(1, N - 1):
while mid_l < mid and abs(2 * B[mid_l] - B[mid]) >= abs(2 * B[mid_l + 1] - B[mid]):
mid_l += 1
while mid_r < N - 1 and abs(2 * B[mid_r] - B[mid] - t) >= abs(2 * B[mid_r + 1] - B[mid] - t):
mid_r += 1
p = B[mid_l]
q = B[mid] - p
r = B[mid_r] - p - q
s = t - r - p - q
ans = min(ans, max(p, q, r, s) - min(p, q, r, s))
print(ans) | p03310 |
# coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
A = inpl()
B = A[:]
# 累積和
for i in range(1, N):
B[i] = B[i] + B[i - 1]
ans = INF
mid_l = 0
mid_r = 2
t = B[-1]
for mid in range(1, N - 1):
while mid_l < mid and abs(2 * B[mid_l] - B[mid]) >= abs(2 * B[mid_l + 1] - B[mid]):
mid_l += 1
while mid_r < N - 1 and abs(2 * B[mid_r] - B[mid] - t) >= abs(2 * B[mid_r + 1] - B[mid] - t):
mid_r += 1
p = B[mid_l]
q = B[mid] - p
r = B[mid_r] - p - q
s = t - r - p - q
ans = min(ans, max(p, q, r, s) - min(p, q, r, s))
print(ans) | # coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
N = int(eval(input()))
A = inpl()
B = A[:]
# 累積和
for i in range(1, N):
B[i] = B[i] + B[i - 1]
ans = INF
mid_l = 0
mid_r = 2
t = B[-1]
for mid in range(1, N - 1):
while B[mid] > B[mid_l] + B[mid_l + 1]:
mid_l += 1
while t > B[mid_r] + B[mid_r + 1] - B[mid]:
mid_r += 1
p = B[mid_l]
q = B[mid] - p
r = B[mid_r] - p - q
s = t - r - p - q
ans = min(ans, max(p, q, r, s) - min(p, q, r, s))
print(ans)
| p03310 |
N = int(eval(input()))
A = list(map(int, input().split()))
R = [0] * (N + 1)
for i in range(N):
R[i + 1] += R[i] + A[i]
#print(R)
ans = 10 ** 15
for i in range(3, N):#R[:i]とR[i:]に切る
l, r = 2, i + 1
#R[:l], R[l:i], R[i:r], R[r:]
#R[l - 1] と R[i - 1] - R[l - 1] の差を考える
while abs(R[i - 1] - 2 * R[l]) <= abs(R[i - 1] - 2 * R[l - 1]):
l += 1
#R[r - 1] - R [i - 1] と R[N] - R[r - 1] の差を考える
while abs(R[N] - 2 * R[r] + R[i - 1]) <= abs(R[N] - 2 * R[r - 1] + R[i - 1]):
r += 1
now_max = max(max(R[l - 1], R[i - 1] - R[l - 1]), max(R[r - 1] - R[i - 1], R[N] - R[r - 1]))
now_min = min(min(R[l - 1], R[i - 1] - R[l - 1]), min(R[r - 1] - R[i - 1], R[N] - R[r - 1]))
ans = min(ans, now_max - now_min)
#print(a, b, c, d, ans, ans2)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
R = [0] * (N + 1)
for i in range(N):
R[i + 1] += R[i] + A[i]
#print(R)
ans = 10 ** 15
l, r = 2, 4
for i in range(3, N):#R[:i]とR[i:]に切る
#R[:l], R[l:i], R[i:r], R[r:]
#R[l - 1] と R[i - 1] - R[l - 1] の差を考える
while abs(R[i - 1] - 2 * R[l]) <= abs(R[i - 1] - 2 * R[l - 1]):
l += 1
#R[r - 1] - R [i - 1] と R[N] - R[r - 1] の差を考える
while abs(R[N] - 2 * R[r] + R[i - 1]) <= abs(R[N] - 2 * R[r - 1] + R[i - 1]):
r += 1
now_max = max(max(R[l - 1], R[i - 1] - R[l - 1]), max(R[r - 1] - R[i - 1], R[N] - R[r - 1]))
now_min = min(min(R[l - 1], R[i - 1] - R[l - 1]), min(R[r - 1] - R[i - 1], R[N] - R[r - 1]))
ans = min(ans, now_max - now_min)
#print(R[l - 1], R[i - 1] - R[l - 1],R[r - 1] - R[i - 1], R[N] - R[r - 1], ans)
print(ans)
| p03310 |
import math
n = int(eval(input()))
a = [int(i) for i in input().split(" ")]
ar = a[::-1]
a = [0] + a
ar = [0] + ar
s = [0] * (n + 1)
sr = [0] * (n + 1)
for i in range(1, n + 1):
s[i] = a[i] + s[i - 1]
sr[i] = ar[i] + sr[i - 1]
def bs(s, l, r, rr):
if l == r:
return l
else:
h = math.ceil((l + r) / 2)
if s[h] * 2 > s[rr]:
return bs(s, l, h - 1, rr)
else:
return bs(s, h, r, rr)
def min_2(s, i, rr):
a = abs(s[i] - (s[rr] - s[i]))
b = abs(s[i + 1] - (s[rr] - s[i + 1]))
if a <= b:
return i
else:
return i + 1
def f(a):
return max(a) - min(a)
m_min = 2 * 10**14
for i in range(2, n - 1):
pq = bs(s, 1, i, i)
rs = bs(sr, 1, n - i, n - i)
pq = min_2(s, pq, i)
rs = min_2(sr, rs, n - i)
m = f([s[pq], s[i] - s[pq], sr[rs], sr[n - i] - sr[rs]])
if m < m_min:
m_min = m
print(m_min) | import math
n = int(eval(input()))
a = [int(i) for i in input().split(" ")]
ar = a[::-1]
a = [0] + a
ar = [0] + ar
s = [0] * (n + 1)
sr = [0] * (n + 1)
li = 0
ri = n
for i in range(1, n + 1):
s[i] = a[i] + s[i - 1]
sr[i] = ar[i] + sr[i - 1]
def f(a):
return max(a) - min(a)
def fs(rr):
global li
while abs(s[rr] - 2 * s[li]) > abs(s[rr] - 2 * s[li + 1]):
li += 1
def fsr(rr):
global ri
while abs(sr[rr] - 2 * sr[ri]) > abs(sr[rr] - 2 * sr[ri - 1]):
ri -= 1
m_min = 2 * 10**14
for i in range(2, n - 1):
fs(i)
fsr(n - i)
m = f([s[li], s[i] - s[li], sr[ri], sr[n - i] - sr[ri]])
if m < m_min:
m_min = m
print(m_min) | p03310 |
from itertools import accumulate
n=int(eval(input()))
a=list(map(int, input().split()))
acc=list(accumulate(a))
sumA=acc[-1]
cut=[0, 1, 2, len(a)-1]
score=[acc[cut[0]], acc[cut[1]]-acc[cut[0]], acc[cut[2]]-acc[cut[1]], acc[cut[3]]-acc[cut[2]]]
ans=max(score)-min(score)
for i in range(1,len(a)-1):
cut[1]=i
while abs(acc[cut[1]]-acc[cut[0]]-acc[cut[0]]) > abs(acc[cut[1]]-acc[cut[0]+1]-acc[cut[0]+1]):
cut[0]+=1
while abs(acc[cut[3]]-acc[cut[2]]-(acc[cut[2]]-acc[cut[1]])) > abs(acc[cut[3]]-acc[cut[2]+1]-(acc[cut[2]+1]-acc[cut[1]])):
cut[2]+=1
score=[acc[cut[0]], acc[cut[1]]-acc[cut[0]], acc[cut[2]]-acc[cut[1]], acc[cut[3]]-acc[cut[2]]]
ans=min(ans, max(score)-min(score))
print(ans)
| from itertools import accumulate
n=int(eval(input()))
a=list(map(int, input().split()))
acc=list(accumulate(a))
left=0; right=2
ans=float('inf')
for center in range(1,n-1):
while abs(acc[center]-acc[left]-acc[left]) > abs(acc[center]-acc[left+1]-acc[left+1]):
left+=1
while abs(acc[n-1]-acc[right]-(acc[right]-acc[center])) > abs(acc[n-1]-acc[right+1]-(acc[right+1]-acc[center])):
right+=1
score=acc[left], acc[center]-acc[left], acc[right]-acc[center], acc[n-1]-acc[right]
ans=min(ans, max(score)-min(score))
print(ans)
| p03310 |
from itertools import accumulate
n=int(eval(input()))
a=list(map(int, input().split()))
acc=list(accumulate(a))
left=0; right=2
ans=float('inf')
for center in range(1,n-1):
while abs(acc[center]-acc[left]-acc[left]) > abs(acc[center]-acc[left+1]-acc[left+1]):
left+=1
while abs(acc[n-1]-acc[right]-(acc[right]-acc[center])) > abs(acc[n-1]-acc[right+1]-(acc[right+1]-acc[center])):
right+=1
score=acc[left], acc[center]-acc[left], acc[right]-acc[center], acc[n-1]-acc[right]
ans=min(ans, max(score)-min(score))
print(ans)
| from itertools import accumulate
n=int(eval(input()))
a=list(map(int, input().split()))
acc=list(accumulate(a))
left=0; center=1; right=2
ans=float('inf')
score=[acc[left], acc[center]-acc[left], acc[right]-acc[center], acc[n-1]-acc[right]]
nextS=[acc[left+1], acc[center]-acc[left+1], acc[right+1]-acc[center], acc[n-1]-acc[right+1]]
for center in range(1,n-1):
while abs(score[1]-score[0]) > abs(nextS[1]-nextS[0]):
left+=1
score[0]+=a[left]
score[1]-=a[left]
nextS[0]+=a[left+1]
nextS[1]-=a[left+1]
while abs(score[3]-score[2]) > abs(nextS[3]-nextS[2]):
right+=1
score[2]+=a[right]
score[3]-=a[right]
nextS[2]+=a[right+1]
nextS[3]-=a[right+1]
ans=min(ans, max(score)-min(score))
score[1]+=a[center+1]
score[2]-=a[center+1]
nextS[1]+=a[center+1]
nextS[2]-=a[center+1]
print(ans)
| p03310 |
def min_diff(x, base=0):
n = len(x)
ok = - 1 # x[ok] - base < x[n - 1] - x[ok]
ng = n - 1
while ng - ok > 1:
mid = (ok + ng) // 2
if x[mid] - base < x[n - 1] - x[mid]:
ok = mid
else:
ng = mid
d_ok = abs((x[ok] - base) - (x[n - 1] - x[ok]))
d_ng = abs((x[ng] - base) - (x[n - 1] - x[ng]))
if d_ok < d_ng:
return (x[ok] - base), (x[n - 1] - x[ok])
else:
return (x[ng] - base), (x[n - 1] - x[ng])
def main():
N = int(eval(input()))
A = list(map(int, input().split(' ')))
X = [0 for _ in range(N)] # cum sum
X[0] = A[0]
for i in range(1, N):
X[i] = X[i - 1] + A[i]
# split to 2 parts (X_0, ..., X_(i-1)), (X_i, ..., X_(N-1))
min_d = 10**10
for i in range(2, N - 1):
p, q = min_diff(X[:i])
r, s = min_diff(X[i:], base=X[i - 1])
d = max([p, q, r, s]) - min([p, q, r, s])
min_d = min([min_d, d])
print(min_d)
if __name__ == '__main__':
main() | def main():
N = int(eval(input()))
A = list(map(int, input().split(' ')))
X = [0 for _ in range(N + 1)] # cum sum
for i in range(N):
X[i + 1] = X[i] + A[i]
# split to 2 parts (X_0, ..., X_i), (X_(i+1), ..., X_N)
ans = 10**10
left = 0
right = 2
for i in range(1, N):
while left < i:
d = abs(X[left] - (X[i] - X[left]))
d_next = abs(X[left + 1] - (X[i] - X[left + 1]))
if d_next > d:
break
left += 1
while right < N:
d = abs((X[N] - X[right]) - (X[right] - X[i]))
d_next = abs((X[N] - X[right + 1]) - (X[right + 1] - X[i]))
if d_next > d:
break
right += 1
p, q, r, s = X[left], X[i] - X[left], X[right] - X[i], X[N] - X[right]
ans = min([ans, max([p, q, r, s]) - min([p, q, r, s])])
print(ans)
if __name__ == '__main__':
main() | p03310 |
n=int(eval(input()))
a=list(map(int,input().split()))
a=[sum(a[:i])+a[i] for i in range(len(a))]
j=0
k=2
ans=10**9
for i in range(1,n-1):
while abs(a[j]*2-a[i])>abs(a[j+1]*2-a[i]):
j+=1
while abs(a[k]*2-a[i]-a[n-1])>abs(a[k+1]*2-a[i]-a[n-1]):
k+=1
t=[a[j],a[i]-a[j],a[k]-a[i],a[n-1]-a[k]]
ans=min(ans,max(t)-min(t))
print(ans) | n=int(eval(input()))
a=[int(i) for i in input().split()]
for i in range(n-1):
a[i+1]+=a[i]
j=0
k=2
ans=10**9
for i in range(1,n-1):
while abs(a[j]*2-a[i])>abs(a[j+1]*2-a[i]):
j+=1
while abs(a[k]*2-a[i]-a[n-1])>abs(a[k+1]*2-a[i]-a[n-1]):
k+=1
t=[a[j],a[i]-a[j],a[k]-a[i],a[n-1]-a[k]]
ans=min(ans,max(t)-min(t))
print(ans) | p03310 |
INF = 2 * 10**5 * 10**9
n = int(eval(input()))
a = list(map(int,input().split()))
s = [0]
for x in a:
s.append(s[-1]+x)
ans = INF
p1 = 1
p = 2
p2 = 3
def update():
global ans
if p1 < p and p2 < n:
ans = min(ans , max(s[p1],s[p]-s[p1],s[p2]-s[p],s[n]-s[p2]) - min(s[p1],s[p]-s[p1],s[p2]-s[p],s[n]-s[p2]) )
if p2 < n and p1 - 1 >= 1:
ans = min(ans , max(s[p1-1],s[p]-s[p1-1],s[p2]-s[p],s[n]-s[p2]) - min(s[p1-1],s[p]-s[p1-1],s[p2]-s[p],s[n]-s[p2]) )
if p1 < p and p2-1 >= p:
ans = min(ans , max(s[p1],s[p]-s[p1],s[p2-1]-s[p],s[n]-s[p2-1]) - min(s[p1],s[p]-s[p1],s[p2-1]-s[p],s[n]-s[p2-1]) )
if p1-1 >= 1 and p2-1 >= p:
ans = min(ans , max(s[p1-1],s[p]-s[p1-1],s[p2-1]-s[p],s[n]-s[p2-1]) - min(s[p1-1],s[p]-s[p1-1],s[p2-1]-s[p],s[n]-s[p2-1]) )
while p2 < n and s[p2] - s[p] < s[n] - s[p2]:
p2 += 1
update()
while True:
p += 1
if p + 1 >= n:
break
while p1 < p and s[p1] < s[p] - s[p1]:
p1 += 1
while p2 < n and s[p2] - s[p] < s[n] - s[p2]:
p2 += 1
update()
print(ans) | INF = 2 * 10**5 * 10**9
n = int(eval(input()))
a = list(map(int,input().split()))
s = [0]
for x in a:
s.append(s[-1]+x)
ans = INF
p1 = 1
p = 1
p2 = 3
while True:
p += 1
if p + 1 >= n:
break
while p1 < p and abs(s[p1] - s[p] + s[p1]) > abs(s[p1+1] - s[p] + s[p1 + 1]):
p1 += 1
while p2 < n and abs(s[p2] - s[p] - s[n] + s[p2]) > abs(s[p2+1] - s[p] - s[n] + s[p2+1]):
p2 += 1
ans = min(ans , max(s[p1],s[p]-s[p1],s[p2]-s[p],s[n]-s[p2]) - min(s[p1],s[p]-s[p1],s[p2]-s[p],s[n]-s[p2]) )
print(ans) | p03310 |
n = int(eval(input()))
a = list(map(int,input().split()))
b = a[0]
c = a[1]
d = a[2]
e = sum(a[3:n])
p = 0
q = 1
r = 2
while r+1 <= n-2 and abs((d+a[r+1])-(e-a[r+1])) < abs(d-e):
r += 1
d += a[r]
e -= a[r]
m = max(b,c,d,e) - min(b,c,d,e)
while q <= n-4:
q += 1
c += a[q]
d -= a[q]
while p+1 <= q-1 and abs((b+a[p+1])-(c-a[p+1])) <= abs(b-c):
b += a[p+1]
c -= a[p+1]
p += 1
while r+1 <= n-2 and abs((d+a[r+1])-(e-a[r+1])) <= abs(d-e):
d += a[r+1]
e -= a[r+1]
r += 1
m = min(m,max(b,c,d,e) - min(b,c,d,e))
print(m)
| n = int(eval(input()))
a = list(map(int,input().split()))
b,c,d,e = 0,a[0],a[1],sum(a[2:n])
p,q,r = -1,1,1
m = sum(a)
while q <= n-3:
c += a[q]
d -= a[q]
while p+1 <= q-1 and abs(b-c+2*a[p+1]) <= abs(b-c):
p += 1
b += a[p]
c -= a[p]
while r+1 <= n-2 and abs(d-e+2*a[r+1]) <= abs(d-e):
r += 1
d += a[r]
e -= a[r]
m = min(m,max(b,c,d,e) - min(b,c,d,e))
q += 1
print(m) | p03310 |
import bisect
n = int(eval(input()))
a = list(map(int, input().split()))
cum = [0] * (n+1)
for i in range(n):
cum[i+1] = cum[i] + a[i]
cum.append(10**10)
mincost = 10 ** 10
for mid in range(2,n-1):
ll = bisect.bisect_left(cum[:mid], cum[mid]//2)
rl = bisect.bisect_left(cum[mid:], cum[mid+1] + (cum[n] - cum[mid+1])//2) + mid
s = [0] * 4
lw = abs(2*cum[ll] - cum[mid]) > abs(2*cum[ll-1] - cum[mid])
rw = abs(2*cum[rl] - cum[mid] - cum[n]) > abs(2*cum[rl-1] - cum[mid] - cum[n])
sums = [cum[ll - lw], cum[mid] - cum[ll - lw], cum[rl - rw] - cum[mid], cum[n] - cum[rl - rw]]
mincost = min(mincost, max(sums) - min(sums))
print(mincost)
| n = int(eval(input()))
a = list(map(int, input().split()))
cum = [0] * (n+1)
for i in range(n):
cum[i+1] = cum[i] + a[i]
llsum = a[0]
lrsum = a[1]
l = [0] * n
l[2] = 1
for mid in range(3, n-1):
new = a[mid-1]
lrsum += new
l[mid] = l[mid-1]
unk = a[l[mid]]
while(abs(lrsum - llsum) > abs(lrsum - llsum - 2 * unk)):
llsum += unk
lrsum -= unk
l[mid] += 1
unk = a[l[mid]]
rrsum = a[n-1]
rlsum = a[n-2]
r = [0] * n
r[n-2] = n-1
for mid in reversed(list(range(2, n-2))):
new = a[mid]
rlsum += new
r[mid] = r[mid+1]
unk = a[r[mid] - 1]
while(abs(rlsum - rrsum) > abs(rlsum - rrsum - 2 * unk)):
rrsum += unk
rlsum -= unk
r[mid] -= 1
unk = a[r[mid] - 1]
minabs = 10 ** 20
for mid in range(2, n-1):
c0 = cum[l[mid]]
c1 = cum[mid]
c2 = cum[r[mid]]
sums = (c0, c1 - c0, c2 - c1, cum[n] - c2)
minabs = min(minabs, max(sums) - min(sums))
print(minabs)
| p03310 |
N=int(eval(input()))
A=list(map(int,input().split()))
h=[0]
for a in A:
h.append(a+h[-1])
h.pop(0)
def spl_l(i,b):
while abs(h[i]-2*h[b])>abs(h[i]-2*h[b+1]):
b+=1
return b
def spl_r(i,b):
while abs(h[-1]-2*h[b]+h[i])>abs(h[-1]-2*h[b+1]+h[i]):
b+=1
return b
def calc(j,i,k,h):
j=spl_l(i,j)
k=spl_r(i,k)
pqrs=[h[j],h[i]-h[j],h[k]-h[i],h[-1]-h[k]]
ans=max(pqrs)-min(pqrs)
return ans
j=0
k=2
ans=calc(j,1,k,h)
for i in range(2,N-2):
ans=min(ans,calc(j,i,k,h))
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
h=[0]
for a in A:
h.append(a+h[-1])
h.pop(0)
def spl_l(i,b):
while abs(h[i]-2*h[b])>abs(h[i]-2*h[b+1]):
b+=1
return b
def spl_r(i,b):
while abs(h[-1]-2*h[b]+h[i])>abs(h[-1]-2*h[b+1]+h[i]):
b+=1
return b
def calc(j,i,k):
pqrs=[h[j],h[i]-h[j],h[k]-h[i],h[-1]-h[k]]
ans=max(pqrs)-min(pqrs)
return ans
j=0
k=2
ans=18**20
for i in range(1,N-2):
j=spl_l(i,j)
k=spl_r(i,k)
ans=min(ans,calc(j,i,k))
print(ans)
| p03310 |
n,m=list(map(int,input().split()))
List=[]
for i in range(m):
road=list(map(int,input().split()))
List.append(road)
road=[road[1],road[0]]
List.append(road)
ans=0
for i in range(1,n+1):
for j in range(len(List)):
if i==List[j][0]:
ans+=1
print(ans)
ans=0
| n,m=list(map(int,input().split()))
List=[]
for i in range(m):
a,b=list(map(int,input().split()))
List.append([a,b])
List.append([b,a])
ans=0
for i in range(1,n+1):
for j in range(len(List)):
if i==List[j][0]:
ans+=1
print(ans)
ans=0 | p03720 |
n, m = list(map(int, input().split()))
route_lists = [input().split() for i in range(m)]
new_lists = []
for i in route_lists:
for j in range(2):
new_lists.append(i[j])
new_lists.sort()
for i in range(1, n+1, 1):
print((new_lists.count(str(i)))) | n, m = list(map(int, input().split()))
route_lists = [input().split() for i in range(m)]
new_lists = []
for i in route_lists:
for j in range(2):
new_lists.append(i[j])
for i in range(1, n+1, 1):
print((new_lists.count(str(i)))) | p03720 |
n, m = list(map(int, input().split()))
d = []
for i in range(m):
a, b = list(map(int, input().split()))
d.append(a)
d.append(b)
d = sorted(d)
for i in range(1, n + 1):
count = 0
for j in range(len(d)):
if d[j] == i:
count += 1
print(count)
| n, m = list(map(int, input().split()))
d = [0]*n
for i in range(m):
a, b = list(map(int, input().split()))
d[a - 1] += 1
d[b - 1] += 1
for i in d:
print(i) | p03720 |
n, m = (int(i) for i in input().split())
city2city = [0] * n
for i in range(m):
a,b = (int(i) for i in input().split())
city2city[a-1] += 1
city2city[b-1] += 1
for c in city2city:
print(c)
| def main():
N, M = (int(i) for i in input().split())
c = [0 for i in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
c[a-1] += 1
c[b-1] += 1
print(*c, sep="\n")
if __name__ == '__main__':
main()
| p03720 |
N,_,*L=map(int,open(0).read().split())
A=[0]*N
for l in L: A[l-1]+=1
print(*A,sep='\n')
| N,_,*L=list(map(int,open(0).read().split()))
for n in range(N):print((L.count(n+1))) | p03720 |
import sys
from collections import Counter
sys.setrecursionlimit(10**7)
inf = 1<<100
def solve():
N, M = map(int, input().split())
ans = [0]*N
for i in range(M):
ai, bi = map(int, input().split())
ai -= 1
bi -= 1
ans[ai] += 1
ans[bi] += 1
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| import sys
def solve():
N, M = map(int, input().split())
deg = [0] * N
for i in range(M):
ai, bi = map(int, input().split())
ai, bi = ai - 1, bi - 1
deg[ai] += 1
deg[bi] += 1
print(*deg, sep='\n')
if __name__ == '__main__':
solve()
| p03720 |
from collections import Counter
n,m=list(map(int,input().split()))
L=[0]*(2*m)
for i in range(m):
L[2*i],L[2*i+1]=list(map(int,input().split()))
s=Counter(L)
for i in range(n):
print((s[i+1])) | n,m=map(int,input().split())
ans=[0]*n
for _ in range(m):
a,b=map(int,input().split())
ans[a-1] += 1
ans[b-1] += 1
print(*ans, sep="\n")
| p03720 |
N,M= list(map(int,input().split()))
f = [0] * (N + 2)
for i in range(M):
x,y = list(map(int,input().split()))
f[x]+=1
f[y]+=1
for i in range(1,N+1):
print((f[i])) | # 061 B
N,M= list(map(int,input().split()))
f = [0] * (N + 20)
for i in range(M):
x,y = list(map(int,input().split()))
f[x]+=1
f[y]+=1
for i in range(1,N+1):
print((f[i])) | p03720 |
n, m = list(map(int, input().split()))
a = [0] * m
b = [0] * m
for i in range(m):
a[i], b[i] = list(map(int, input().split()))
count = 0
for i in range(1, n + 1):
count = a.count(i) + b.count(i)
print(count) | n, m = list(map(int, input().split()))
a = [0] * m
b = [0] * m
for i in range(m):
a[i], b[i] = list(map(int, input().split()))
road = [0] * n
for i in range(m):
road[a[i] - 1] += 1
road[b[i] - 1] += 1
for i in range(n):
print((road[i])) | p03720 |
# -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
N, M = list(map(int, input().split()))
l = []
for i in range(N):
l.append(0)
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1; b -= 1;
l[a] += 1
l[b] += 1
for i in range(N):
print((l[i]))
| # -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
N, M = list(map(int, input().split()))
l = [0] * N
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1; b -= 1;
l[a] += 1
l[b] += 1
for i in range(N):
print((l[i])) | p03720 |
from collections import defaultdict
N, M = list(map(int, input().split()))
city_road_nums = defaultdict(int)
for _ in range(M):
a, b = list(map(int, input().split()))
city_road_nums[a] += 1
city_road_nums[b] += 1
for i in range(1, N+1):
print((city_road_nums[i]))
| N, M = list(map(int, input().split()))
ABs = [input().split() for i in range(M)]
MPs = {}
for a, b in ABs:
a = int(a)
b = int(b)
if a not in MPs:
MPs[a] = 1
else:
MPs[a] += 1
if b not in MPs:
MPs[b] = 1
else:
MPs[b] += 1
for mp in range(1, N+1):
if mp not in MPs:
MPs[mp] = '0'
for _, y in sorted(MPs.items()):
print(y) | p03720 |
N, M = list(map(int, input().split()))
A = []
B = []
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
AB = A + B
# 各都市間の道路の本数は、ABに含まれる各都市の個数（番号）に等しい
roadsCntArray = []
# 入力に含まれる都市の個数を数える
for i in range(N):
roadsCntArray.append(AB.count(i+1))
for i in range(N):
print((roadsCntArray[i])) | N, M = list(map(int, input().split()))
A = []
B = []
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
AB = A + B
# 各都市間の道路の本数は、ABに含まれる各都市の個数（番号）に等しい
roadsCntArray = []
# 入力に含まれる都市の個数を数える
for i in range(N):
roadsCntArray.append(AB.count(i+1))
print((roadsCntArray[i])) | p03720 |
n, m = list(map(int, input().split()))
RD = list(list(map(int, input().split())) for _ in range(m))
for i in range(1, n + 1):
ans = 0
for j in RD:
ans += j.count(i)
print(ans) | n, m = list(map(int, input().split()))
NRD = list(0 for i in range(n))
for i in range(m):
r1, r2 = list(map(int, input().split()))
NRD[r1 - 1] += 1
NRD[r2 - 1] += 1
for i in range(n):
print((NRD[i])) | p03720 |
N,M=list(map(int,input().split()))
li=[]
for i in range(M):
a,b=list(map(int,input().split()))
li.append(a)
li.append(b)
ans=[0]*N
for j in range(1,N+1):
cj=li.count(j)
ans[j-1]=cj
for k in range(N):
print((ans[k]))
| N,M=list(map(int,input().split()))
li=[0]*N
for i in range(M):
a,b=list(map(int,input().split()))
li[a-1]+=1
li[b-1]+=1
for j in range(N):
print((li[j]))
| p03720 |
a = list(map(int,input().split()))
b = [list(map(int,input().split())) for i in range(a[1])]
c = []
for i in range(a[0]):
d = []
for j in range(a[1]):
d.append(b[j].count(i+1))
else:
c.append(sum(d))
else:
for i in range(a[0]):
print((c[i])) | N,M = list(map(int,input().split()))
z = []
for i in range(M):
a,b = list(map(int,input().split()))
z.append(a)
z.append(b)
for i in range(N):
print((z.count(i+1)))
| p03720 |
N,M,*A=list(map(int,open(0).read().split()));l=[0]*N
for a,b in zip(A[::2],A[1::2]):l[a-1]+=1;l[b-1]+=1
for r in l:print(r) | N,M,*A=list(map(int,open(0).read().split()));l=[0]*N
for a in A:l[a-1]+=1
for r in l:print(r) | p03720 |
def getlist():
return list(map(int, input().split()))
n,m = getlist()
cities = [0 for i in range(n)]
for i in range(m):
a,b = getlist()
cities[a-1] += 1
cities[b-1] += 1
print(("\n".join(list(map(str, cities))))) | n,m = list(map(int, input().split()))
cities = [0 for i in range(n)]
for i in range(m):
bridges = list(map(int, input().split()))
cities = [x+1 if i+1 in bridges else x for i,x in enumerate(cities)]
print(("\n".join(list(map(str, cities))))) | p03720 |
n,m = list(map(int, input().split()))
adj = [[] for i in range(n)]
for i in range(m):
a,b = list(map(int, input().split()))
a-=1
b-=1
adj[a].append(b)
adj[b].append(a)
for i in adj:
print((len(i))) | N,M = (int(x) for x in input().split())
result = [0]*N
for i in range(M):
a,b = (int(x) for x in input().split())
result[a-1] += 1
result[b-1] += 1
for i in result:
print(i) | p03720 |
N, M = list(map(int,input().split()))
A = [list(map(int,input().split())) for _ in range(M)]
d = {}
for i in range(1,N+1):
d[i] = 0
for i in range(M):
a, b = A[i][0], A[i][1]
d[a] += A[i].count(a)
d[b] += A[i].count(b)
for k, v in list(d.items()):
print(v) | N, M = list(map(int,input().split()))
d = [0]*(N)
for _ in range(M):
a, b = list(map(int,input().split()))
d[a-1] += 1
d[b-1] += 1
for v in d:
print(v) | p03720 |
n,m = list(map(int,input().split()))
abm = [list(map(int,input().split())) for _ in range(m)]
countDic = {}
for nn in range(n+1):
countDic[nn] = 0
for ab in abm:
countDic[ab[0]] += 1
countDic[ab[1]] += 1
ks = list(countDic.keys())
ks = sorted(ks)[1:]
for k in ks:
print((countDic[k])) | n,m = list(map(int,input().split()))
ans = [0]*n
for _ in range(m):
a,b = list(map(int,input().split()))
ans[a-1]+=1
ans[b-1]+=1
for an in ans:
print(an) | p03720 |
n,m=list(map(int,input().split()))
ls=[0]*(n+1)
for i in range(m):
a,b= list(map(int,input().split()))
ls[a]+=1
ls[b]+=1
for j in range(1,n+1):
print((ls[j])) | n,m=list(map(int,input().split()))
s=[0]*(n+1)
for i in range(m):
a,b=list(map(int,input().split()))
s[a]+=1
s[b]+=1
for i in range(1,n+1):
print((s[i])) | p03720 |
N,M = list(map(int,input().split()))
cint = [0,0]*M
for i in range(M):
cint[i]=list(map(int,input().split()))
for i in range(1,N+1):
count=0
for j in range(M):
if cint[j][0] == i or cint[j][1] == i:
count +=1
print(count) | N,M = list(map(int,input().split()))
count =[0]*N
for i in range(M):
ca,cb=list(map(int,input().split()))
count[ca-1] +=1
count[cb-1] +=1
for i in range(N):
print((count[i]))
| p03720 |
class Dice(object):
"""Dice Class
"""
def __init__(self, numbers):
"""
Args:
numbers:
"""
self.numbers_inverse = {numbers[0]: 1, numbers[1]: 2, numbers[2]: 3, numbers[3]: 4, numbers[4]: 5,
numbers[5]: 6}
self.numbers = {1: numbers[0], 2: numbers[1], 3: numbers[2], 4: numbers[3], 5: numbers[4], 6: numbers[5]}
self.vertical = [self.numbers[1], self.numbers[2], self.numbers[6], self.numbers[5]]
self.horizontal = [self.numbers[4], self.numbers[1], self.numbers[3], self.numbers[6]]
def roll_dice(self, str):
"""
Args:
str: move direction
Returns:
"""
for s in str:
if s == 'N':
self.move_north()
elif s == 'S':
self.move_south()
elif s == 'W':
self.move_west()
elif s == 'E':
self.move_east()
def set_top(self, value):
"""
Args:
value: target_value
"""
counter = 0
while counter < 4:
if self.vertical[0] == value:
self.map_values()
return
else:
self.roll_dice("S")
counter += 1
counter = 0
while counter < 4:
if self.vertical[0] == value:
self.map_values()
return
else:
self.roll_dice("W")
counter += 1
def set_front(self, value):
"""
Args:
value: target value
"""
counter = 0
while counter < 4:
if self.vertical[1] == value:
self.map_values()
return
else:
self.roll_dice("SWN")
counter += 1
def move_south(self):
"""move this dice towered north
"""
self.vertical = (self.vertical * 2)[3:7]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
self.map_values()
def move_north(self):
"""move this dice towered south
"""
self.vertical = (self.vertical * 2)[1:5]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
self.map_values()
def move_east(self):
"""move this dice towered east
"""
self.horizontal = (self.horizontal * 2)[3:7]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
self.map_values()
def move_west(self):
"""move this dice towered west
"""
self.horizontal = (self.horizontal * 2)[1:5]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
self.map_values()
def map_values(self):
self.numbers[1] = self.vertical[0]
self.numbers[2] = self.vertical[1]
self.numbers[3] = self.horizontal[2]
self.numbers[4] = self.horizontal[0]
self.numbers[5] = self.vertical[3]
self.numbers[6] = self.vertical[2]
def get_top(self):
return self.vertical[0]
def is_same(dice1, dice2):
"""compare two dices
Args:
dice1: dice1
dice2: dice2
Returns:
Bool (whether dice1 is equals to be dice2 or not)
"""
flag = False
if dice1.numbers == dice2.numbers:
flag = True
else:
for i in range(6):
dice1.set_top(i + 1)
for j in range(4):
dice1.roll_dice("SWN")
if dice1.numbers == dice2.numbers:
flag = True
dice1.roll_dice("S")
return flag
dice_number = int(input())
dices = []
counter = 0
while counter < dice_number:
dices.append(Dice([int(x) for x in input().split()]))
counter += 1
ans = 0
for i in range(dice_number - 1):
if ans > 0:
break
for j in range(i + 1, dice_number):
ans += int(is_same(dices[i], dices[j]))
if ans > 0:
print("No")
break
if ans == 0:
print("Yes") | class Dice(object):
"""Dice Class
"""
def __init__(self, numbers):
"""
Args:
numbers:
"""
self.numbers_inverse = {numbers[0]: 1, numbers[1]: 2, numbers[2]: 3, numbers[3]: 4, numbers[4]: 5,
numbers[5]: 6}
self.numbers = {1: numbers[0], 2: numbers[1], 3: numbers[2], 4: numbers[3], 5: numbers[4], 6: numbers[5]}
self.vertical = [self.numbers[1], self.numbers[2], self.numbers[6], self.numbers[5]]
self.horizontal = [self.numbers[4], self.numbers[1], self.numbers[3], self.numbers[6]]
def roll_dice(self, str):
"""
Args:
str: move direction
Returns:
"""
for s in str:
if s == 'N':
self.move_north()
elif s == 'S':
self.move_south()
elif s == 'W':
self.move_west()
elif s == 'E':
self.move_east()
def set_top(self, value):
"""
Args:
value: target_value
"""
counter = 0
while counter < 4:
if self.vertical[0] == value:
self.map_values()
return
else:
self.roll_dice("S")
counter += 1
counter = 0
while counter < 4:
if self.vertical[0] == value:
self.map_values()
return
else:
self.roll_dice("W")
counter += 1
def set_front(self, value):
"""
Args:
value: target value
"""
counter = 0
while counter < 4:
if self.vertical[1] == value:
self.map_values()
return
else:
self.roll_dice("SWN")
counter += 1
def move_south(self):
"""move this dice towered north
"""
self.vertical = (self.vertical * 2)[3:7]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
self.map_values()
def move_north(self):
"""move this dice towered south
"""
self.vertical = (self.vertical * 2)[1:5]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
self.map_values()
def move_east(self):
"""move this dice towered east
"""
self.horizontal = (self.horizontal * 2)[3:7]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
self.map_values()
def move_west(self):
"""move this dice towered west
"""
self.horizontal = (self.horizontal * 2)[1:5]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
self.map_values()
def map_values(self):
self.numbers[1] = self.vertical[0]
self.numbers[2] = self.vertical[1]
self.numbers[3] = self.horizontal[2]
self.numbers[4] = self.horizontal[0]
self.numbers[5] = self.vertical[3]
self.numbers[6] = self.vertical[2]
def get_top(self):
return self.vertical[0]
def is_same(dice1, dice2):
"""compare two dices
Args:
dice1: dice1
dice2: dice2
Returns:
Bool (whether dice1 is equals to be dice2 or not)
"""
flag = False
if dice1.numbers == dice2.numbers:
flag = True
elif set(dice1.numbers_inverse.keys()) != set(dice2.numbers_inverse.keys()):
flag = False
else:
for i in range(6):
dice1.set_top(i + 1)
for j in range(4):
dice1.roll_dice("SWN")
if dice1.numbers == dice2.numbers:
flag = True
dice1.roll_dice("S")
return flag
dice_number = int(input())
dices = []
counter = 0
while counter < dice_number:
dices.append(Dice([int(x) for x in input().split()]))
counter += 1
ans = 0
for i in range(dice_number - 1):
if ans > 0:
break
for j in range(i + 1, dice_number):
ans += int(is_same(dices[i], dices[j]))
if ans > 0:
print("No")
break
if ans == 0:
print("Yes") | p02386 |
import random
class Dice:
def __init__(self, num_list):
self.top = num_list[0]
self.dside = num_list[1]
self.rside = num_list[2]
self.lside = num_list[3]
self.uside = num_list[4]
self.bottom = num_list[5]
self.dlist = num_list
def north(self):
(self.top, self.dside, self.bottom, self.uside) = (self.dside,
self.bottom, self.uside, self.top)
def east(self):
(self.top, self.lside, self.bottom, self.rside) = (self.lside,
self.bottom, self.rside, self.top)
def south(self):
(self.top, self.dside, self.bottom, self.uside) = (self.uside,
self.top, self.dside, self.bottom)
n = int(eval(input()))
num = [list(map(int, input().split())) for i in range(n)]
dice = [Dice(num[i]) for i in range(n)]
for idx1, i in enumerate(dice):
for idx2, j in enumerate(dice):
if idx2 <= idx1:
continue
elif len(set(num[0])) < 4:
while(i.top != j.top or i.rside != j.rside
or i.dside != j.dside):
mode = random.randint(0, 2)
if mode == 0:
j.north()
elif mode == 1:
j.east()
else:
j.south()
else:
while(i.top != j.top or
(i.rside != j.rside and i.uside != j.uside)):
mode = random.randint(0, 2)
if mode == 0:
j.north()
elif mode == 1:
j.east()
elif mode == 2:
j.south()
if (i.bottom == j.bottom and i.lside == j.lside
and i.dside == j.dside):
print("No")
break
else:
continue
break
else:
print("Yes")
| import random
class Dice:
def __init__(self, num_list):
self.top = num_list[0]
self.dside = num_list[1]
self.rside = num_list[2]
self.lside = num_list[3]
self.uside = num_list[4]
self.bottom = num_list[5]
self.dlist = num_list
def north(self):
(self.top, self.dside, self.bottom, self.uside) = (self.dside,
self.bottom, self.uside, self.top)
def east(self):
(self.top, self.lside, self.bottom, self.rside) = (self.lside,
self.bottom, self.rside, self.top)
def south(self):
(self.top, self.dside, self.bottom, self.uside) = (self.uside,
self.top, self.dside, self.bottom)
n = int(eval(input()))
num = [list(map(int, input().split())) for i in range(n)]
dice = [Dice(num[i]) for i in range(n)]
for idx1, i in enumerate(dice):
for idx2, j in enumerate(dice):
if idx2 <= idx1 or len(set(i.dlist)^set(j.dlist)):
continue
elif len(set(num[0])) < 4:
while(i.top != j.top or i.rside != j.rside
or i.dside != j.dside):
mode = random.randint(0, 2)
if mode == 0:
j.north()
elif mode == 1:
j.east()
else:
j.south()
else:
while(i.top != j.top or
(i.rside != j.rside and i.uside != j.uside)):
mode = random.randint(0, 2)
if mode == 0:
j.north()
elif mode == 1:
j.east()
elif mode == 2:
j.south()
if (i.bottom == j.bottom and i.lside == j.lside
and i.dside == j.dside):
print("No")
break
else:
continue
break
else:
print("Yes")
| p02386 |
n = int(input())
dice = [[0 for i in range(6)] for j in range(n)]
for i in range(n):
dice[i] = list(map(int, input().split()))
def rolling(inst, dice):
if inst == 'E':
dice[5], dice[2], dice[0], dice[3] = dice[2], dice[0], dice[3], dice[5]
elif inst == 'W':
dice[5], dice[3], dice[0], dice[2] = dice[3], dice[0], dice[2], dice[5]
elif inst == 'N':
dice[5], dice[4], dice[0], dice[1] = dice[4], dice[0], dice[1], dice[5]
elif inst == 'S':
dice[5], dice[1], dice[0], dice[4] = dice[1], dice[0], dice[4], dice[5]
def dice_matching(dice1, dice2):
if dice1[1] == dice2[1]:
for i in range(4):
if dice1 == dice2:
return 1
break
rolling('E', dice2)
return 0
else:
return 0
flag = 0
for i in range(n):
for j in range(i+1, n):
count = 0
while(1):
if dice_matching(dice[i], dice[j]) == 1:
flag = 1
print('No')
break
else:
if count < 3:
rolling('N', dice[j])
count += 1
elif 7 > count and count >= 3:
if count == 3:
rolling('E', dice[j])
rolling('N', dice[j])
count += 1
else:
break
if flag ==1:
break
if flag == 1:
break
if flag == 0:
print('Yes') | n = int(input())
dice = [[0 for i in range(6)] for j in range(n)]
for i in range(n):
dice[i] = list(map(int, input().split()))
def rolling(inst, dice):
if inst == 'E':
dice[5], dice[2], dice[0], dice[3] = dice[2], dice[0], dice[3], dice[5]
elif inst == 'W':
dice[5], dice[3], dice[0], dice[2] = dice[3], dice[0], dice[2], dice[5]
elif inst == 'N':
dice[5], dice[4], dice[0], dice[1] = dice[4], dice[0], dice[1], dice[5]
elif inst == 'S':
dice[5], dice[1], dice[0], dice[4] = dice[1], dice[0], dice[4], dice[5]
def dice_matching(dice1, dice2):
if dice1[1] == dice2[1]:
for i in range(4):
if dice1 == dice2:
return 1
break
rolling('E', dice2)
return 0
else:
return 0
def alldice_matching(dice1, dice2):
count = 0
while(1):
if dice_matching(dice1, dice2) == 1:
return 1
else:
if count < 3:
rolling('N', dice2)
count += 1
elif 7 > count and count >= 3:
if count == 3:
rolling('E', dice2)
rolling('N', dice2)
count += 1
else:
return 0
flag = 0
for i in range(n):
for j in range(i+1, n):
if alldice_matching(dice[i], dice[j]) == 1:
flag = 1
print("No")
break
if flag == 1:
break
if flag == 0:
print('Yes') | p02386 |
from itertools import*
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
for k in range(n):
b=a[k];b[3],b[4]=b[4],b[3]
t=0
lst=list(combinations(a,2))
for d,e in lst:
for i in range(6):
m=('012345','152043','215304','302541','410352','514320')[i]
f=[d[int(k)]for k in m]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for j in range(4):
if f[j:j+4]==e[1:5]:t=1
print((('Yes','No')[t==1]))
| n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
for k in range(n):
b=a[k];b[3],b[4]=b[4],b[3]
t=0
for i in range(n-1):
d=a[i]
for j in range(i+1,n):
e=a[j]
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(k)]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:t=1
print((('Yes','No')[t]))
| p02386 |
import sys
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(k)]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:print('No');sys.exit()
print('Yes')
| n=int(input())
a=[list(map(int,input().split()))for _ in range(n)]
def f():
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(k)]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return print('No')
print('Yes')
f()
| p02386 |
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
def f():
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(k)]for k in p]
g=f[1:5]*2
for k in range(4):
if g[k:k+4]==e[1:5]:
if f[0]==e[0]:
if f[5]==e[5]:return 'No'
return 'Yes'
print((f()))
| n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
def f():
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(k)]for k in p]
if f[0]==e[0]:
if f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return 'No'
return 'Yes'
print((f()))
| p02386 |
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
def f():
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[k]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| n=int(eval(input()))
a=[[int(s)for s in input().split()]for _ in range(n)]
def f():
for i in range(n-1):
d=a[i][:];d[3],d[4]=d[4],d[3]
for j in range(i+1,n):
e=a[j][:];e[3],e[4]=e[4],e[3]
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[k]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| p02386 |
from itertools import*
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
def f():
for p,q in list(combinations(a,2)):
d=p[:];d[3],d[4]=d[4],d[3]
e=q[:];e[3],e[4]=e[4],e[3]
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[k]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| from itertools import*
n=int(eval(input()))
a=[list(map(int,input().split()))for _ in range(n)]
for k in range(n):
b=a[k];b[3],b[4]=b[4],b[3]
def f():
for d,e in list(combinations(a,2)):
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[k]for k in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| p02386 |
from itertools import*
def g():
n=int(eval(input()))
a=[[s for s in input().split()]for _ in range(n)]
for b in a:
b[3:5]=b[4],b[3]
t=0
for d,e in combinations(a,2):
for p in('012345','152043','215304','302541','410352','514320'):
f=[d[int(i)]for i in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:t=1
print((['Yes','No'][t]))
g()
| from itertools import*
n=int(eval(input()))
a=[input().split()for _ in[0]*n]
for b in a:
b[3:5]=b[4],b[3]
def f():
for d,e in combinations(a,2):
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[i]for i in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| p02386 |
from itertools import*
n=int(eval(input()))
a=[input().split()for _ in[0]*n]
for b in a:
b[3:5]=b[4],b[3]
def f():
for d,e in combinations(a,2):
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[i]for i in p]
if f[0]==e[0]and f[5]==e[5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((f()))
| from itertools import*
n=int(eval(input()))
a=[input().split()for _ in[0]*n]
for b in a:
b[3:5]=b[4],b[3]
def g():
for d,e in combinations(a,2):
for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):
f=[d[i]for i in p]
if f[0::5]==e[0::5]:
f=f[1:5]*2
for k in range(4):
if f[k:k+4]==e[1:5]:return'No'
return'Yes'
print((g()))
| p02386 |
class Dice:
def __init__(self):
self.u=1
self.w=2
self.s=3
self.e=4
self.n=5
self.d=6
self.dic={"W":0,"S":1,"E":2,"N":3}
def __init__(self,u,w,s,e,n,d):
self.u=u
self.w=w
self.s=s
self.e=e
self.n=n
self.d=d
self.dic={"W":0,"S":1,"E":2,"N":3}
def rot(self,way):
if isinstance(way,str):
way=self.dic[way]
if(way==0):
c=self.u
self.u=self.e
self.e=self.d
self.d=self.w
self.w=c
elif way==1:
c=self.u
self.u=self.n
self.n=self.d
self.d=self.s
self.s=c
elif way==2:
c=self.u
self.u=self.w
self.w=self.d
self.d=self.e
self.e=c
def mk_dice():
u,s,e,w,n,d=list(map(int,input().split()))
return Dice(u,w,s,e,n,d)
import random
q=int(eval(input()))
dice_col=[]
ans=True
for j in range(q):
dice_b=mk_dice()
for dice in dice_col:
for i in range (1000):
dice.rot(random.randint(0,3))
if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
ans=False
dice_col.append(dice_b)
if ans:
print('Yes')
else:
print('No') | class Dice:
def __init__(self):
self.u=1
self.w=2
self.s=3
self.e=4
self.n=5
self.d=6
self.dic={"W":0,"S":1,"E":2,"N":3}
def __init__(self,u,w,s,e,n,d):
self.u=u
self.w=w
self.s=s
self.e=e
self.n=n
self.d=d
self.dic={"W":0,"S":1,"E":2,"N":3}
def rot(self,way):
if isinstance(way,str):
way=self.dic[way]
if(way==0):
c=self.u
self.u=self.e
self.e=self.d
self.d=self.w
self.w=c
elif way==1:
c=self.u
self.u=self.n
self.n=self.d
self.d=self.s
self.s=c
elif way==2:
c=self.u
self.u=self.w
self.w=self.d
self.d=self.e
self.e=c
def get_nums(self):
return {self.u,self.w,self.s,self.e,self.n,self.w,self.d}
def mk_dice():
u,s,e,w,n,d=list(map(int,input().split()))
return Dice(u,w,s,e,n,d)
import random
q=int(eval(input()))
dice_col=[]
ans=True
for j in range(q):
dice_b=mk_dice()
for dice in dice_col:
if(dice.get_nums()==dice_b.get_nums()):
for i in range (1000):
dice.rot(random.randint(0,2))
if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
ans=False
dice_col.append(dice_b)
if ans:
print('Yes')
else:
print('No') | p02386 |
class Dice:
def __init__(self):
self.u=1
self.w=2
self.s=3
self.e=4
self.n=5
self.d=6
self.dic={"W":0,"S":1,"E":2,"N":3}
def __init__(self,u,w,s,e,n,d):
self.u=u
self.w=w
self.s=s
self.e=e
self.n=n
self.d=d
self.dic={"W":0,"S":1,"E":2,"N":3}
def rot(self,way):
if isinstance(way,str):
way=self.dic[way]
if(way==0):
c=self.u
self.u=self.e
self.e=self.d
self.d=self.w
self.w=c
elif way==1:
c=self.u
self.u=self.n
self.n=self.d
self.d=self.s
self.s=c
elif way==2:
c=self.u
self.u=self.w
self.w=self.d
self.d=self.e
self.e=c
def get_nums(self):
return {self.u,self.w,self.s,self.e,self.n,self.w,self.d}
def mk_dice():
u,s,e,w,n,d=list(map(int,input().split()))
return Dice(u,w,s,e,n,d)
import random
q=int(eval(input()))
dice_col=[]
ans=True
for j in range(q):
dice_b=mk_dice()
for dice in dice_col:
if(dice.get_nums()==dice_b.get_nums()):
for i in range (1000):
dice.rot(random.randint(0,2))
if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
ans=False
dice_col.append(dice_b)
if ans:
print('Yes')
else:
print('No') | class Dice:
def __init__(self):
self.u=1
self.w=2
self.s=3
self.e=4
self.n=5
self.d=6
self.dic={"W":0,"S":1,"E":2,"N":3}
def __init__(self,u,w,s,e,n,d):
self.u=u
self.w=w
self.s=s
self.e=e
self.n=n
self.d=d
self.dic={"W":0,"S":1,"E":2,"N":3}
def rot(self,way):
if isinstance(way,str):
way=self.dic[way]
if(way==0):
c=self.u
self.u=self.e
self.e=self.d
self.d=self.w
self.w=c
elif way==1:
c=self.u
self.u=self.n
self.n=self.d
self.d=self.s
self.s=c
elif way==2:
c=self.u
self.u=self.w
self.w=self.d
self.d=self.e
self.e=c
def get_nums(self):
return {self.u,self.w,self.s,self.e,self.n,self.w,self.d}
def mk_dice():
u,s,e,w,n,d=list(map(int,input().split()))
return Dice(u,w,s,e,n,d)
import random
q=int(eval(input()))
dice_col=[]
ans=True
for j in range(q):
dice_b=mk_dice()
for dice in dice_col:
if(dice.get_nums()==dice_b.get_nums()):
for i in range (1000):
dice.rot(random.randint(0,2))
if(dice.u==dice_b.u and dice.d==dice_b.d and dice.w==dice_b.w and dice.s==dice_b.s and dice.e==dice_b.e and dice.n==dice_b.n):
ans=False
if ~ans:
break
dice_col.append(dice_b)
if ans:
print('Yes')
else:
print('No') | p02386 |
import random
class Dice(object):
def __init__(self):
self.t = 1
self.s = 2
self.e = 3
self.w = 4
self.n = 5
self.b = 6
def __init__(self, faces):
self.t = faces[0]
self.s = faces[1]
self.e = faces[2]
self.w = faces[3]
self.n = faces[4]
self.b = faces[5]
def roll(self, direct):
if direct == 0:
self.t, self.s, self.b, self.n = self.n, self.t, self.s, self.b
elif direct == 1:
self.t, self.w, self.b, self.e = self.e, self.t, self.w, self.b
elif direct == 2:
self.n, self.w, self.s, self.e = self.w, self.s, self.e, self.n
def is_equal(self, dice):
if self.t == dice.t and self.s == dice.s and self.e == dice.e and self.w == dice.w and self.n == dice.n and self.b == dice.b:
return True
else:
return False
n = int(eval(input()))
dice_list = []
flag_list = []
for _ in range(n):
flag = False
faces = list(map(int, input().split()))
dice_list.append(Dice(faces))
if n == 0:
continue
dice_a = dice_list[-1]
for i in range(len(dice_list) - 1):
dice_b = dice_list[i]
for i in range(1000):
dice_b.roll(random.randint(0, 3))
if dice_a.is_equal(dice_b):
flag = True
break
flag_list.append(flag)
if any(flag_list):
print('No')
else:
print('Yes')
| import random
class Dice(object):
def __init__(self):
self.t = 1
self.s = 2
self.e = 3
self.w = 4
self.n = 5
self.b = 6
def __init__(self, faces):
self.t = faces[0]
self.s = faces[1]
self.e = faces[2]
self.w = faces[3]
self.n = faces[4]
self.b = faces[5]
def roll(self, direct):
if direct == 0:
self.t, self.s, self.b, self.n = self.n, self.t, self.s, self.b
elif direct == 1:
self.t, self.w, self.b, self.e = self.e, self.t, self.w, self.b
elif direct == 2:
self.n, self.w, self.s, self.e = self.w, self.s, self.e, self.n
def is_equal(self, dice):
if self.t == dice.t and self.s == dice.s and self.e == dice.e and self.w == dice.w and self.n == dice.n and self.b == dice.b:
return True
else:
return False
n = int(eval(input()))
dice_list = []
flag_list = []
for _ in range(n):
flag = False
faces = list(map(int, input().split()))
dice_list.append(Dice(faces))
if n == 0:
continue
dice_a = dice_list[-1]
for i in range(len(dice_list) - 1):
dice_b = dice_list[i]
for i in range(500):
dice_b.roll(random.randint(0, 3))
if dice_a.is_equal(dice_b):
flag = True
break
flag_list.append(flag)
if any(flag_list):
print('No')
else:
print('Yes')
| p02386 |
def main():
n = int(eval(input()))
dices = []
for i in range(n):
dices.append(Dice(list(map(int, input().split(' ')))))
if not equals_any(dices):
print('Yes')
else:
print('No')
def equals_any(dices):
for i, d1 in enumerate(dices):
for d2 in [d for d in dices[i+1:]]:
if equals(d1, d2):
return True
return False
def equals(d1, d2):
for i in range(4):
for j in range(4):
if d1.equals(d2):
return True
d2.toE()
d2.toN()
d2.toE().toN()
for i in range(2):
for j in range(4):
if d1.equals(d2):
return True
d2.toE()
d2.toN().toN()
return False
class Dice:
def __init__(self, labels):
self.labels = labels
self._tb = (0, 5)
self._fb = (1, 4)
self._lr = (3, 2)
def toN(self):
tb = self._tb
self._tb = self._fb
self._fb = tuple(reversed(tb))
return self
def toS(self):
tb = self._tb
self._tb = tuple(reversed(self._fb))
self._fb = tb
return self
def toW(self):
tb = self._tb
self._tb = tuple(reversed(self._lr))
self._lr = tb
return self
def toE(self):
tb = self._tb
self._tb = self._lr
self._lr = tuple(reversed(tb))
return self
def get_top(self):
return self.labels[self._tb[0]]
def get_bottom(self):
return self.labels[self._tb[1]]
def get_front(self):
return self.labels[self._fb[0]]
def get_back(self):
return self.labels[self._fb[1]]
def get_left(self):
return self.labels[self._lr[0]]
def get_right(self):
return self.labels[self._lr[1]]
top = property(get_top)
bottom = property(get_bottom)
front = property(get_front)
back = property(get_back)
left = property(get_left)
right = property(get_right)
def equals(self, other):
if not (self.top == other.top and self.bottom == other.bottom):
return False
if not (self.front == other.front and self.back == other.back):
return False
if not (self.left == other.left and self.right == other.right):
return False
return True
def __str__(self):
return str([self.top, self.front, self.right, self.left, self.back, self.bottom])
if __name__ == '__main__':
main() | class Dice:
def __init__(self, nums):
self.top = nums[0]
self.front = nums[1]
self.right = nums[2]
self.left = nums[3]
self.back = nums[4]
self.bottom = nums[5]
def toN(self):
tmp = self.top
self.top = self.front
self.front = self.bottom
self.bottom = self.back
self.back = tmp
def toS(self):
tmp = self.top
self.top = self.back
self.back = self.bottom
self.bottom = self.front
self.front = tmp
def toE(self):
tmp = self.top
self.top = self.left
self.left = self.bottom
self.bottom = self.right
self.right = tmp
def toW(self):
tmp = self.top
self.top = self.right
self.right = self.bottom
self.bottom = self.left
self.left = tmp
def moveTo(self, ds):
for d in ds:
if d == 'N':
self.toN()
if d == 'S':
self.toS()
if d == 'E':
self.toE()
if d == 'W':
self.toW()
def getTop(self):
return self.top
def getBottom(self):
return self.bottom
def getFront(self):
return self.front
def getBack(self):
return self.back
def getLeft(self):
return self.left
def getRight(self):
return self.right
def __eq__(self, other):
if self.top != other.top:
return False
if self.bottom != other.bottom:
return False
if self.front != other.front:
return False
if self.back != other.back:
return False
if self.left != other.left:
return False
if self.right != other.right:
return False
return True
def moveTo(dice, top, front):
if dice.getFront() != front:
if dice.getTop() == front:
dice.moveTo("S")
elif dice.getBottom() == front:
dice.moveTo("N")
elif dice.getBack() == front:
dice.moveTo("NN")
elif dice.getLeft() == front:
dice.moveTo("ES")
elif dice.getRight() == front:
dice.moveTo("WS")
if dice.getTop() != top:
if dice.getBottom() == top:
dice.moveTo("EE")
elif dice.getLeft() == top:
dice.moveTo("E")
elif dice.getRight() == top:
dice.moveTo("W")
return dice
def equalDice(dice1, dice2):
dice2 = moveTo(dice2, dice1.getTop(), dice1.getFront())
return dice1 == dice2
def main():
n = int(eval(input()))
dice1 = Dice(input().split())
ans = "Yes"
for _ in range(n-1):
dice2 = Dice(input().split())
if equalDice(dice1, dice2):
ans = "No"
break
print(ans)
if __name__ == '__main__':
main()
| p02386 |
def roll(die, d):
if d == "E":
return [die[3], die[1], die[0], die[5], die[4], die[2]]
if d == "N":
return [die[1], die[5], die[2], die[3], die[0], die[4]]
if d == "S":
return [die[4], die[0], die[2], die[3], die[5], die[1]]
if d == "W":
return [die[2], die[1], die[5], die[0], die[4], die[3]]
if d == "L":
return [die[0], die[3], die[1], die[4], die[2], die[5]]
if d == "R":
return [die[0], die[2], die[4], die[1], die[3], die[5]]
def checkdice(die1, die2):
ans = False
for d in "RRRNRRRNRRRSRRRSRRRNRRRR":
if die1 == die2:
ans = True
break
die2 = roll(die2, d)
return ans
dice = []
msg = "Yes"
n = int(eval(input()))
for _ in range(n):
dice.append(list(map(int, input().split())))
for i in range(n):
for j in range(i + 1, n):
if checkdice(dice[i], dice[j]):
msg = "No"
print(msg) | def roll(die, d):
if d == "E":
return [die[3], die[1], die[0], die[5], die[4], die[2]]
if d == "N":
return [die[1], die[5], die[2], die[3], die[0], die[4]]
if d == "S":
return [die[4], die[0], die[2], die[3], die[5], die[1]]
if d == "W":
return [die[2], die[1], die[5], die[0], die[4], die[3]]
if d == "L":
return [die[0], die[3], die[1], die[4], die[2], die[5]]
if d == "R":
return [die[0], die[2], die[4], die[1], die[3], die[5]]
def checkdice(die1, die2):
ans = False
for d in "RRRNRRRNRRRSRRRSRRRNRRRR":
if die1 == die2:
ans = True
break
die2 = roll(die2, d)
return ans
dice = []
msg = "Yes"
n = int(eval(input()))
for _ in range(n):
dice.append(list(map(int, input().split())))
for i in range(n):
for j in range(i + 1, n):
if checkdice(dice[i], dice[j]):
msg = "No"
break
if msg == "No":
break
print(msg) | p02386 |
import copy, sys
class Dice(object):
def __init__(self, nums):
self.top, self.front, self.right, self.left, self.back, self.bottom = nums
def roll(self, directions):
if directions == 'E':
self.top, self.right, self.left, self.bottom = self.left, self.top, self.bottom, self.right
return
if directions == 'N':
self.top, self.front, self.back, self.bottom = self.front, self.bottom, self.top, self.back
return
if directions == 'S':
self.top, self.front, self.back, self.bottom = self.back, self.top, self.bottom, self.front
return
if directions == 'W':
self.top, self.right, self.left, self.bottom = self.right, self.bottom, self.top, self.left
return
self.roll(directions[0])
self.roll(directions[1:])
def equal(self, dice):
d = copy.copy(self)
if(dice.front == d.top):
d.roll('S')
elif(dice.front == d.right):
d.roll('WS')
elif(dice.front == d.left):
d.roll('ES')
elif(dice.front == d.back):
d.roll('SS')
elif(dice.front == d.bottom):
d.roll('N')
if(dice.top == d.right):
d.roll('W')
elif(dice.top == d.left):
d.roll('E')
elif(dice.top == d.bottom):
d.roll('WW')
return not(dice.top != d.top or dice.front != d.front or dice.right != d.right or dice.left != d.left or dice.back != d.back or dice.bottom != d.bottom)
if __name__ == '__main__':
n = int(eval(input()))
dices = []
for i in range(n):
d = Dice([int(_) for _ in input().split()])
for dice in dices:
if d.equal(dice):
print('No')
sys.exit()
dices.append(d)
print('Yes') | import copy, sys
class Dice(object):
def __init__(self, nums):
self.top, self.front, self.right, self.left, self.back, self.bottom = nums
def roll(self, directions):
if directions == 'E':
self.top, self.right, self.left, self.bottom = self.left, self.top, self.bottom, self.right
return
if directions == 'N':
self.top, self.front, self.back, self.bottom = self.front, self.bottom, self.top, self.back
return
if directions == 'S':
self.top, self.front, self.back, self.bottom = self.back, self.top, self.bottom, self.front
return
if directions == 'W':
self.top, self.right, self.left, self.bottom = self.right, self.bottom, self.top, self.left
return
self.roll(directions[0])
self.roll(directions[1:])
def equal(self, dice):
d = copy.copy(self)
if(dice.front == d.top):
d.roll('S')
elif(dice.front == d.right):
d.roll('WS')
elif(dice.front == d.left):
d.roll('ES')
elif(dice.front == d.back):
d.roll('SS')
elif(dice.front == d.bottom):
d.roll('N')
if(dice.top == d.right):
d.roll('W')
elif(dice.top == d.left):
d.roll('E')
elif(dice.top == d.bottom):
d.roll('WW')
return not(dice.top != d.top or dice.front != d.front or dice.right != d.right or dice.left != d.left or dice.back != d.back or dice.bottom != d.bottom)
if __name__ == '__main__':
n = int(eval(input()))
dices = [[] for _ in range(600)]
for i in range(n):
nums = [int(_) for _ in input().split()]
d = Dice(nums)
s = sum(nums)
for dice in dices[s]:
if d.equal(dice):
print('No')
sys.exit()
dices[s].append(d)
print('Yes') | p02386 |
class Dice:
def __init__(self):
# 初期値がない場合
# 上, 南、東、西、北、下にそれぞれ1, 2, 3, 4, 5, 6がくる想定
self.t = 1
self.s = 2
self.e = 3
self.w = 4
self.n = 5
self.b = 6
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def __init__(self, t, s, e, w, n, b):
# 初期値が指定される場合
self.t = t
self.s = s
self.e = e
self.w = w
self.n = n
self.b = b
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def rot(self, way):
if way == 0:
self.t, self.s, self.e, self.w, self.n, self.b = self.n, self.t, self.e, self.w, self.b, self.s
elif way == 1:
self.t, self.s, self.e, self.w, self.n, self.b = self.s, self.b, self.e, self.w, self.t, self.n
elif way == 2:
self.t, self.s, self.e, self.w, self.n, self.b = self.w, self.s, self.t, self.b, self.n, self.e
elif way == 3:
self.t, self.s, self.e, self.w, self.n, self.b = self.e, self.s, self.b, self.t, self.n, self.w
def main():
import random
n = int(eval(input()))
diceList = [[0 for _ in range(6)] for _ in range(n)]
for i in range(n):
diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5] = list(map(int, input().split()))
flag = 0
# 2つ目以降のさいころが、以前のさいころと一致しているか確認していく。
for i in range(1, n):
if flag == 1:
break
else:
dice_a = Dice(diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5])
for j in range(i):
dice_b = Dice(diceList[j][0],diceList[j][1],diceList[j][2],diceList[j][3],diceList[j][4],diceList[j][5])
for _ in range(1000):
if (dice_a.t, dice_a.s, dice_a.e, dice_a.w, dice_a.n, dice_a.b) == (dice_b.t, dice_b.s, dice_b.e, dice_b.w, dice_b.n, dice_b.b):
flag = 1
break
else:
seed = random.randint(0, 3)
dice_a.rot(seed)
if flag == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| class Dice:
def __init__(self):
# 初期値がない場合
# 上, 南、東、西、北、下にそれぞれ1, 2, 3, 4, 5, 6がくる想定
self.t = 1
self.s = 2
self.e = 3
self.w = 4
self.n = 5
self.b = 6
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def __init__(self, t, s, e, w, n, b):
# 初期値が指定される場合
self.t = t
self.s = s
self.e = e
self.w = w
self.n = n
self.b = b
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def rot(self, way):
if way == 0:
self.t, self.s, self.e, self.w, self.n, self.b = self.n, self.t, self.e, self.w, self.b, self.s
elif way == 1:
self.t, self.s, self.e, self.w, self.n, self.b = self.s, self.b, self.e, self.w, self.t, self.n
elif way == 2:
self.t, self.s, self.e, self.w, self.n, self.b = self.w, self.s, self.t, self.b, self.n, self.e
elif way == 3:
self.t, self.s, self.e, self.w, self.n, self.b = self.e, self.s, self.b, self.t, self.n, self.w
def main():
import random
n = int(eval(input()))
diceList = [[0 for _ in range(6)] for _ in range(n)]
for i in range(n):
diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5] = list(map(int, input().split()))
flag = 0
# 2つ目以降のさいころが、以前のさいころと一致しているか確認していく。
for i in range(1, n):
if flag == 1:
break
else:
dice_a = Dice(diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5])
for j in range(i):
dice_b = Dice(diceList[j][0],diceList[j][1],diceList[j][2],diceList[j][3],diceList[j][4],diceList[j][5])
for _ in range(200):
if (dice_a.t, dice_a.s, dice_a.e, dice_a.w, dice_a.n, dice_a.b) == (dice_b.t, dice_b.s, dice_b.e, dice_b.w, dice_b.n, dice_b.b):
flag = 1
break
else:
seed = random.randint(0, 3)
dice_a.rot(seed)
if flag == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| p02386 |
class Dice:
def __init__(self):
# 初期値がない場合
# 上, 南、東、西、北、下にそれぞれ1, 2, 3, 4, 5, 6がくる想定
self.t = 1
self.s = 2
self.e = 3
self.w = 4
self.n = 5
self.b = 6
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def __init__(self, t, s, e, w, n, b):
# 初期値が指定される場合
self.t = t
self.s = s
self.e = e
self.w = w
self.n = n
self.b = b
self.rotway = {"S": 0, "N": 1, "E": 2, "W": 3}
def rot(self, way):
if way == 0:
self.t, self.s, self.e, self.w, self.n, self.b = self.n, self.t, self.e, self.w, self.b, self.s
elif way == 1:
self.t, self.s, self.e, self.w, self.n, self.b = self.s, self.b, self.e, self.w, self.t, self.n
elif way == 2:
self.t, self.s, self.e, self.w, self.n, self.b = self.w, self.s, self.t, self.b, self.n, self.e
elif way == 3:
self.t, self.s, self.e, self.w, self.n, self.b = self.e, self.s, self.b, self.t, self.n, self.w
def main():
import random
n = int(eval(input()))
diceList = [[0 for _ in range(6)] for _ in range(n)]
for i in range(n):
diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5] = list(map(int, input().split()))
flag = 0
# 2つ目以降のさいころが、以前のさいころと一致しているか確認していく。
for i in range(1, n):
if flag == 1:
break
else:
dice_a = Dice(diceList[i][0],diceList[i][1],diceList[i][2],diceList[i][3],diceList[i][4],diceList[i][5])
for j in range(i):
dice_b = Dice(diceList[j][0],diceList[j][1],diceList[j][2],diceList[j][3],diceList[j][4],diceList[j][5])
for _ in range(100):
if (dice_a.t, dice_a.s, dice_a.e, dice_a.w, dice_a.n, dice_a.b) == (dice_b.t, dice_b.s, dice_b.e, dice_b.w, dice_b.n, dice_b.b):
flag = 1
break
else:
seed = random.randint(0, 3)
dice_a.rot(seed)
if flag == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
dices=[]
same = 0
for _ in range(n):
dices.append(list(map(int, input().split())))
for i in range(n-1):
for j in range(i+1,n):
same += check_dice(dices[i], dices[j])
if same >= 1:
print('No')
break
if same == 0:
print('Yes')
def check_dice(f, s):
yes = 0
for _ in range(4):
s[0],s[2],s[5],s[3] = s[2],s[5],s[3],s[0]
for _ in range(4):
s[1],s[2],s[4],s[3] = s[2],s[4],s[3],s[1]
if f == s:
yes = 1
for _ in range(4):
s[0],s[1],s[5],s[4] = s[1],s[5],s[4],s[0]
for _ in range(4):
s[1],s[2],s[4],s[3] = s[2],s[4],s[3],s[1]
if f == s:
yes = 1
return yes
if __name__ == '__main__':
main()
| p02386 |
def check(x, y):
z = [0, 1, 2]
for i in range(6):
order = [0, 0, 0]
for j in range(3):
if {x[j], x[-j-1]} != {y[z[j]], y[-z[j]-1]}:
break
if x[j] == y[z[j]]:
order[j] = 1
if x[j] == x[-j-1]:
order[j] = 2
else:
if 2 in order or (i < 3) == sum(order) % 2:
return True
z = [z[2], z[0], z[1]]
if i == 2:
z = [z[0], z[2], z[1]]
return False
n = int(eval(input()))
x = [[] for i in range(n)]
for i in range(n):
x[i] = input().split()
for i in range(n):
for j in range(i+1, n, 1):
if check(x[i], x[j]):
break
else:
continue
print('No')
break
else:
print('Yes') | def check(x, y):
for i in range(6):
order = [0, 0, 0]
for j in range(3):
if {x[j], x[-j-1]} != {y[z[i][j]], y[-z[i][j]-1]}:
break
if x[j] == y[z[i][j]]:
order[j] = 1
if x[j] == x[-j-1]:
order[j] = 2
else:
if 2 in order or z[i][3] == sum(order) % 2:
return True
return False
n = int(eval(input()))
x = [[] for i in range(n)]
for i in range(n):
x[i] = list(map(int, input().split()))
z = [[0, 1, 2, 1], [0, 2, 1, 0], [2, 1, 0, 0], [1, 0, 2, 0], [2, 0, 1, 1], [1, 2, 0, 1]]
different = True
for i in range(n):
for j in range(i+1, n, 1):
if check(x[i], x[j]):
break
else:
continue
print('No')
break
else:
print('Yes') | p02386 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.