input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N = int(eval(input()))
T, A = list(map(int, input().split()))
Hn = list(map(int, input().split()))
An = [T - 0.006*i for i in Hn]
tp = [10000000]*(N+1)
tpa = N
for i in range(N):
tp[i] = abs(A - An[i])
tpa = i if tp[i] < tp[tpa] else tpa
print((tpa+1)) | N = int(eval(input()))
T, A = list(map(int, input().split()))
Hn = list(map(int, input().split()))
An = [abs(A - (T - 0.006*i)) for i in Hn]
print((An.index(min(An))+1)) | p03220 |
# coding: utf-8
pointCount = int(eval(input()))
(t, a) = [int(i) for i in input().rstrip().split(" ")]
point_lit = [int(i) for i in input().rstrip().split(" ")]
min_diff = 100000
ans = 0
for i in range(len(point_lit)):
kion = t - (point_lit[i] * 0.006)
diff = abs(a - kion)
if diff < min_diff:
min_diff = diff
ans = i + 1
print(ans) | # coding: utf-8
n = int(eval(input()))
(t, a) = [int(i) for i in input().rstrip().split(" ")]
point_list = [int(i) for i in input().rstrip().split(" ")]
ans = -1
nearest = 100000
for i in range(n):
kion = abs(t - (point_list[i] * 0.006) - a)
if kion < nearest:
ans = i + 1
nearest = kion
print(ans)
| p03220 |
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
Th = [T - h * 0.006 for h in H]
answer = -1
dif = 10 ** 15
for i, t in enumerate(Th, 1):
if abs(A - t) < dif:
answer = i
dif = abs(A - t)
print(answer) | import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
answer = -1
dif = 10 ** 15
for i, h in enumerate(H, 1):
if abs(A - (T - h * 0.006)) < dif:
answer = i
dif = abs(A - (T - h * 0.006))
print(answer) | p03220 |
n=int(eval(input()))
t,a=[int(i) for i in input().split()]
h_list=[int(i) for i in input().split()]
a_list=[abs(a-(t-i*0.006)) for i in h_list]
print((a_list.index(min(a_list))+1)) | n=int(eval(input()))
t,a=[int(i) for i in input().split()]
h_list=[int(i) for i in input().split()]
#絶対値のリスト
abs_list=[]
for i in range(n):
abs_list.append(abs(a-(t-h_list[i]*0.006)))
print((abs_list.index(min(abs_list))+1))
| p03220 |
N=int(eval(input()))
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
P=float("inf")
X=B=0
for i in range(N) :
X=abs(A-(T-H[i]*0.006))
if X<P :
B=i
P=X
print((B+1)) | N=int(eval(input()))
T,A=list(map(int,input().split()))
L=[]
for i in map(int,input().split()) :
B=abs(A-(T-i*0.006))
L.append(B)
print((L.index(min(L))+1))
| p03220 |
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i, h in enumerate(H):
d = abs(A - (T - h * 0.006))
mn = (i, d) if mn is None or mn[1] > d else mn
print((mn[0] + 1)) | N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i in range(N):
x = abs(A - (T - H[i] * 0.006))
if mn is None or x < mn[1]:
mn = (i, x)
print((mn[0] + 1)) | p03220 |
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
AveT = []
diff = []
for i in range(N):
AveT.append(T - H[i]*0.006)
diff.append(abs(AveT[i] - A))
for i in range(N):
if diff[i] == min(diff):
place = i + 1
print(place) | N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
AveT = [T - h*0.006 for h in H]
diff = [abs(Ave_t - A) for Ave_t in AveT]
print((diff.index(min(diff)) + 1)) | p03220 |
#n = 候補の数
n = int(eval(input()))
#t - h[i] * 0.006
#a = 基準温度
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
#o = 計算結果格納
o = []
for i in range(n):
o.append(t - h[i] * 0.006)
#p = 基準温度に最も近い場所の差
p = abs(a - o[0])
#q = 基準地点の番号
q = 0
for i in range(n)[1:]:
if abs(a - o[i]) < p:
p = abs(a - o[i])
q = i
print((q + 1)) | n = int(eval(input()))
t,a = list(map(int,input().split()))
h = list(map(int,input().split()))
p = 10 ** 8
ans = 0
for i in range(n):
x = t - h[i] * 0.006
x = abs(a - x)
if p > x:
p = x
ans = i + 1
print(ans) | p03220 |
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
for i in range(N):
H[i] = abs(T - H[i]*0.006 - A)
print((H.index(min(H))+1)) | N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
MIN = 10000
ans = 10000
for i in range(N):
if MIN > abs((T - H[i]*0.006) - A):
MIN = abs((T - H[i]*0.006) - A)
ans = i
print((ans+1)) | p03220 |
import sys
input = sys.stdin.readline
def main():
ans = 0
N = int(eval(input()))
T, A = list(map(int, input().split()))
h = list(map(int, input().split()))
temp = float('inf')
for i in range(N):
d = T - h[i]*0.006
if abs(A - temp) > abs(A - d):
temp = d
ans = i+1
print(ans)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
l = []
N = int(eval(input()))
T, A = list(map(int, input().split()))
h = list(map(int, input().split()))
for i in range(N):
l.append(abs(A-(T-h[i]*0.006)))
print((l.index(min(l))+1))
if __name__ == '__main__':
main() | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
listh = list(map(int, input().split()))
temp = 100000
index = 0
for i in range(n):
diff = abs((t - listh[i] * 0.006)-a)
if temp > diff:
temp = diff
index = i+1
print(index)
| n = int(eval(input()))
t, a = list(map(int, input().split()))
listh = list(map(int, input().split()))
diff = [abs((t-x*0.006)-a) for x in listh]
print((diff.index(min(diff))+1))
| p03220 |
N=int(eval(input()))
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
num=0
for i in range(N):
if i==0:
num=(T-H[0]*0.006)
spot=0
else:
if abs(A-(T-H[i]*0.006))<=abs(A-num):
num=(T-H[i]*0.006)
spot=i
print((spot+1))
| N=int(eval(input()))
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
ans=[]
for i in H:
ans.append(abs(A-(T-i*0.006)))
print((ans.index(min(ans))+1))
| p03220 |
N=int(eval(input()))
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
m=100100100100
for i in range(N):
if abs(A-T+H[i]*0.006)<m:
m=abs(A-T+H[i]*0.006)
ans=i
print((ans+1)) | N=int(eval(input()))
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
z=[abs(A-T+i*0.006) for i in H]
print((z.index(min(z))+1)) | p03220 |
n = int(eval(input()))
t,a = list(map(int,input().split()))
l = []
m = []
ans = []
l = list(map(int,input().split()))
for i in range(n):
m.append(t - (l[i] * 0.006))
for i in range(n):
ans.append(a - m[i])
print((ans.index(min(ans,key=abs))+1)) | n = int(eval(input()))
t,a = list(map(int,input().split()))
ans = []
l = list(map(int,input().split()))
for i in l:
ans.append(abs(a - (t - (i * 0.006))))
print((ans.index(min(ans))+1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
H = list(map(int, input().split()))
ABS = []
for i in H:
ABS.append(abs((t-i*0.006) - a))
print((ABS.index(min(ABS)) + 1)) | n = int(eval(input()))
t, a = list(map(int, input().split()))
H = list(map(int, input().split()))
mtd = 1000
for i in range(n):
if abs(a - (t - (H[i] * 0.006))) < mtd:
mtd = abs(a - (t - (H[i] * 0.006)))
ans = i + 1
print(ans) | p03220 |
import sys
def solve(N, T, A, ls_H):
dosi = []
titen = []
titen1 = []
ti = 10**5//1
for x in ls_H :
do = T - x * 0.006
dosi.append(do)
#print(dosi)
for y in dosi :
til = A - y
titen.append(til)
#print(titen)
for z in titen :
titen1.append(abs(z))
#print(titen1)
for i in titen1 :
if ti > i :
ti = i
#print(ti)
return titen1.index(ti) + 1
def readQuestion():
ws = sys.stdin.readline().strip().split()
N = int(ws[0])
ws = sys.stdin.readline().strip().split()
T = int(ws[0])
A = int(ws[1])
ws = sys.stdin.readline().strip().split()
ls_H = list(map(int, ws))
return (N, T, A, ls_H)
def main():
print((solve(*readQuestion())))
# Uncomment before submission
main() | import sys
def solve(N, T, A, ls_H):
temperature = []
difference = []
near = []
ti = 10**5//1
for x in ls_H :
air = T - x * 0.006
temperature.append(air)
#print(temperature)
for y in temperature :
til = A - y
difference.append(til)
#print(difference)
for z in difference :
near.append(abs(z))
#print(near)
for i in near :
if ti > i :
ti = i
#print(ti)
return near.index(ti) + 1
def readQuestion():
ws = sys.stdin.readline().strip().split()
N = int(ws[0])
ws = sys.stdin.readline().strip().split()
T = int(ws[0])
A = int(ws[1])
ws = sys.stdin.readline().strip().split()
ls_H = list(map(int, ws))
return (N, T, A, ls_H)
def main():
print((solve(*readQuestion())))
# Uncomment before submission
main() | p03220 |
N = int(eval(input()))
T,A = list(map(int,input().split()))
now = 10000000
ans = 0
H = list(map(int,input().split()))
for i in range(N):
tmp = T - H[i]*0.006
if abs(A - tmp) < now:
now = abs(A - tmp)
ans = i+1
print(ans) | N = int(eval(input()))
T,A = list(map(int,input().split()))
H = list(map(int,input().split()))
now = 99999
ans = 0
for i in range(N):
tem = T - H[i] * 0.006
if abs(tem - A ) < now:
now = abs(tem - A)
ans = i+1
print(ans) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
res = 0
cc = float('inf')
for i in range(n):
d = (1000 * t - 6 * h[i]) - 1000 * a
if d < 0: d = -d
if cc > d:
cc = d
res = i + 1
print(res) | N = int(eval(input()))
T, A = list(map(int, input().split()))
h = list(map(int, input().split()))
d = 10 ** 9
ans = -1
for i in range(N):
t = abs((1000 * T - 6 * h[i]) - 1000 * A)
if t < d:
ans = i + 1
d = t
print(ans)
| p03220 |
n=int(eval(input()))
t,a=list(map(int,input().split()))
hi=[int(_) for _ in input().split()]
z=[abs(a-(t-x*0.006)) for x in hi]
print((z.index(min(z))+1)) | n=int(eval(input()))
t,a=list(map(int,input().split()))
h=list(map(int,input().split()))
z=[abs(t-x*0.006-a) for x in h]
print((z.index(min(z))+1)) | p03220 |
N = int(eval(input()))
T,A = list(map(int,input().split()))
H = list(map(int,input().split()))
x = 100000
ans = 0
for i in range(N):
temp = abs(A -(T - H[i]*0.006))
if abs(A -(T - H[i]*0.006)) < x:
x = abs(A -(T - H[i]*0.006))
ans = i
print((ans+1)) | eval(input())
T,A = list(map(int,input().split()))
a = list(map(int,input().split()))
#最小値
min_val = 100000
min_num=0
for i in range(len(a)):
d = abs(T-0.006*a[i]-A)
if d < min_val:
min_val = d
min_num = i
print((min_num+1)) | p03220 |
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
minimum = 10**10
index = 0
for i in range(n):
minimum = min(minimum,abs(a-(t-h[i]*0.006)))
if minimum == abs(a-(t-h[i]*0.006)):
index = i
print((index+1)) | def main():
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
# s = input()
mini = 10**10
ans = 0
for i, x in enumerate(h):
c = t - x * 0.006
if abs(a - c) < mini:
mini = abs(a - c)
ans = i+1
print(ans)
if __name__ == '__main__':
main()
| p03220 |
import sys
n = int(eval(input()))
(t, a) = list(map(int, input().split()))
hs = input().split()
for i in range(len(hs)):
hs[i] = float(hs[i])
ts = []
for h in hs:
ts.append(t - h * 0.006)
min = 0
min_t = sys.maxsize
for i in range(len(hs)):
dt = abs(ts[i] - a)
if dt < min_t:
min = i
min_t = dt
print((min + 1))
| n = int(eval(input()))
(t, a) = list(map(int, input().split()))
h = list(map(int, input().split()))
min_i = 0
min_t = 10 ** 6
for i, h_i in enumerate(h):
diff = abs(t - h_i * 0.006 - a)
if min_t > diff:
min_i = i
min_t = diff
print((min_i + 1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list([abs(t-a-x*0.006) for x in list(map(int, input().split()))])
print((h.index(min(h))+1)) | eval(input())
t, a = list(map(int, input().split()))
hs = list(map(int, input().split()))
arr = []
for h in hs:
arr.append(abs(t - h * 0.006 - a))
print((arr.index(min(arr))+1)) | p03220 |
n,t,a,*h=list(map(int,open(0).read().split()));d,i=9**9,0
for j,v in enumerate(h):
w=abs(a-t+v*0.006)
if w<d:d=w;i=j
print((i+1)) | eval(input());i=lambda:list(map(int,input().split()));t,a=i();h=[abs(t-0.006*x-a)for x in i()];print((h.index(min(h))+1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
ma = 10 ** 9
ans = 0
for i in range(n):
if abs(t - h[i] * 0.006 - a) < ma:
ma = abs(t - h[i] * 0.006 - a)
ans = i + 1
print(ans)
| n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
_abs = 10 ** 9
place = 0
for i in range(n):
tem = t - h[i] * 0.006
if _abs > abs(a - tem):
_abs = abs(a - tem)
place = i + 1
print(place)
| p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
ans = 0
l = a + 10000
for i in range(n):
k = abs(t-h[i]*0.006-a)
if l > k:
l = k
ans = i+1
print(ans) | n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
k = []
for i in range(n):
k.append(abs(t-h[i]*0.006-a))
print((k.index(min(k))+1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
list = [int(i) for i in input().split()]
dif_list = []
answer = 0
for i in range(n):
t_i = t - list[i] * 0.006
t_i_dif = abs(a - t_i)
dif_list.append(t_i_dif)
if min(dif_list) == t_i_dif:
answer = i + 1
print(answer)
| n = int(eval(input()))
t, a = list(map(int, input().split()))
list = [int(i) for i in input().split()]
dif_list = []
for i in range(n):
t_i = t - list[i] * 0.006
t_i_dif = abs(a - t_i)
dif_list.append(t_i_dif)
Min = min(dif_list)
print((dif_list.index(Min) + 1))
| p03220 |
n = int(eval(input()))
avg_temparature, kijun_temparature = list(map(int,input().split()))
list_height = [int(i) for i in input().split()]
result_position = 0
for candidate in range(1,len(list_height)):
a = avg_temparature - (list_height[result_position] * 0.006)
b = avg_temparature - (list_height[candidate] * 0.006)
if abs(kijun_temparature - a) > abs(kijun_temparature - b):
result_position = candidate
print((result_position+1)) | n = int(eval(input()))
t, a = list(map(int,input().split()))
pList = list(map(int,input().split()))
tList = []
for i in range(n):
tList.append(abs(a-(t-pList[i]*0.006)))
result = 0
for i in range(1,n):
if tList[result] > tList[i]:
result = i
print((result+1))
| p03220 |
N = int(eval(input()))
T, A = [int(i) for i in input().split()]
H =[int(i) for i in input().split()]
HH=[abs(A-(T-h*0.006))for h in H]
print((int(HH.index(min(HH))+1))) | N = int(eval(input()))
T, A = list(map(int,input().split()))
H = [int(i) for i in input().split()]
place = [T-i*0.006 for i in H ]
best = [abs(A-place[i]) for i in range(N)]
print((best.index(min(best))+1)) | p03220 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
T, A = list(map(int, input().split()))
Hs = list(map(int, input().split()))
def kion_sa(x):
return abs((T - x * 0.006) - A)
kionsa_list = list()
for i, x in enumerate(Hs):
kionsa_list.append((kion_sa(x), i))
kionsa_list.sort()
print((kionsa_list[0][1]+1))
| N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
deltas = []
for i in range(N):
mean_temp = T - H[i]*0.006
deltas += [abs(mean_temp-A)]
print((deltas.index(min(deltas))+1))
| p03220 |
N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
tempra = [abs((T - h * 0.006) - A) for h in H]
print((tempra.index(min(tempra)) + 1)) | N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
place_avgtmp = [abs(A - (T - h * 0.006)) for h in H]
print((place_avgtmp.index(min(place_avgtmp)) + 1)) | p03220 |
N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
place_avgtmp = [abs(A - (T - h * 0.006)) for h in H]
print((place_avgtmp.index(min(place_avgtmp)) + 1)) | N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
tmp = [abs(A - (T - h*0.006)) for h in H]
print((tmp.index(min(tmp))+1)) | p03220 |
N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
ans = 1e9
for h in H:
x = abs(T-h*0.006-A)
if(ans > x):
tmp = h
ans = x
print((H.index(tmp)+1)) | N = int(eval(input()))
T, A = list(map(int,input().split()))
H = list(map(int,input().split()))
res = [abs(T-h*0.006-A) for h in H]
print((res.index(min(res))+1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
dmin = 10**5
ans = 0
for i in range(n):
d = abs(a - (t - h[i] * 0.006))
if d < dmin:
dmin = d
ans = i
print((ans + 1)) | N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
HH = [abs(A - (T - x * 0.006)) for x in H]
print((HH.index(min(HH)) + 1)) | p03220 |
N = int(eval(input()))
T, A = list(map(int, input().split()))
highs = list(map(int, input().split()))
temps = []
for i in range(N):
temps.append(abs(A-(T-highs[i]*0.006)))
print((temps.index(min(temps))+1)) | N = int(eval(input()))
T, A = list(map(int, input().split()))
highs = list(map(int, input().split()))
temps = []
for i in highs:
diff = abs(A - (T - i*0.006))
temps.append(diff)
print((temps.index(min(temps))+1)) | p03220 |
n = int(eval(input()))
t, a = list(map(int, input().split()))
H = [int(i) for i in input().split()]
A = []
for i in range(n):
x = abs(t - H[i] * 0.006 - a)
A.append(x)
print((A.index(min(A)) + 1)) | n = int(eval(input()))
t, a = list(map(int, input().split()))
H = [int(i) for i in input().split()]
B = []
for i in range(n):
temp = abs(a - (t - H[i] * 0.006))
B.append(temp)
print((B.index(min(B)) + 1)) | p03220 |
from itertools import accumulate
N, K, *A = list(map(int, open(0).read().split()))
def check(d):
r = sorted([v % d for v in A])
r_inv = [d - v for v in r]
r_cs = [0] + list(accumulate(r))
r_inv_cs = list(accumulate(r_inv[::-1]))[::-1] + [0]
ret = False
for i in range(N + 1):
flg1 = r_cs[i] <= K
flg2 = r_cs[i] == r_inv_cs[i]
ret = (flg1 and flg2) or ret
return ret
M = sum(A)
ans = 0
for i in reversed(list(range(1, int(M ** 0.5) + 1))):
if M % i == 0 and check(i):
ans = max(ans, i)
if M % (M // i) == 0 and check(M // i):
ans = max(ans, M // i)
print(ans)
| from itertools import accumulate
N, K, *A = list(map(int, open(0).read().split()))
s = sum(A)
divisor = []
for i in range(1, int(s ** 0.5) + 1):
if s % i == 0:
divisor.append(i)
if i != s // i:
divisor.append(s // i)
ans = 0
for d in divisor:
x = sorted(v % d for v in A)
y = [d - r for r in x]
x_s = [0] + list(accumulate(x))
y_s = list(accumulate(y[::-1]))[::-1] + [0]
for i in range(N + 1):
if x_s[i] <= K and x_s[i] == y_s[i]:
ans = max(ans, d)
break
print(ans)
| p02955 |
from itertools import accumulate
N, K, *A = list(map(int, open(0).read().split()))
s = sum(A)
divisor = []
for i in range(1, int(s ** 0.5) + 1):
if s % i == 0:
divisor.append(i)
if i != s // i:
divisor.append(s // i)
ans = 0
for d in divisor:
x = sorted(v % d for v in A)
y = [d - r for r in x]
x_s = [0] + list(accumulate(x))
y_s = list(accumulate(y[::-1]))[::-1] + [0]
for i in range(N + 1):
if x_s[i] <= K and x_s[i] == y_s[i]:
ans = max(ans, d)
break
print(ans)
|
"""
https://atcoder.jp/contests/abc136/tasks/abc136_e
"""
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
def calc_divisor(x):
divisor = []
for i in range(1, int(x ** 0.5) + 1):
if x % i == 0:
divisor.append(i)
if i != x // i:
divisor.append(x // i)
return divisor
divisor = calc_divisor(sum(X))
ans = 0
for v in divisor:
cand = sorted(x % v for x in X)
cs1 = [0] * (N + 1)
for i in range(N):
cs1[i + 1] = cs1[i] + cand[i]
cs2 = [0] * (N + 1)
for i in reversed(list(range(N))):
cs2[i] = cs2[i + 1] + v - cand[i]
for a, b in zip(cs1, cs2):
if a <= K and a == b:
ans = max(ans, v)
break
print(ans)
| p02955 |
from itertools import accumulate
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A_sum = sum(A)
ans_candidates = []
for n in range(1, int(A_sum ** 0.5) + 1):
if A_sum % n == 0:
ans_candidates.append(n)
ans_candidates.append(A_sum // n)
ans_candidates.sort(reverse=True)
for z in ans_candidates:
need_add = [(z - a % z) % z for a in A]
need_add.sort()
need_minus = [z - na for na in need_add]
need_add = list(accumulate(need_add))
need_minus = list(accumulate(need_minus))
for i in range(N):
if (need_add[i] == need_minus[-1] - need_minus[i]) and (need_add[i] <= K):
print(z)
exit()
| from itertools import accumulate
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = sum(A)
ans_candidates = []
for n in range(1, int(M ** 0.5) + 1):
if M % n == 0:
ans_candidates.append(n)
ans_candidates.append(M // n)
ans = 0
for X in ans_candidates:
need_plus = sorted([(X - a % X) % X for a in A])
need_minus = [X - nm for nm in need_plus]
need_plus = list(accumulate(need_plus))
need_minus = list(accumulate(need_minus))
for i in range(N):
if need_plus[i] > K:
break
if need_plus[i] == (need_minus[-1] - need_minus[i]):
ans = max(ans, X)
break
print(ans)
| p02955 |
from itertools import accumulate
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = sum(A)
ans_candidates = []
for n in range(1, int(M ** 0.5) + 1):
if M % n == 0:
ans_candidates.append(n)
ans_candidates.append(M // n)
ans = 0
for X in ans_candidates:
alpha = sorted([(a % X) for a in A])
beta = [X - a for a in alpha]
alpha = list(accumulate(alpha))
beta = list(accumulate(beta))
for i in range(N):
if alpha[i] > K:
break
if alpha[i] == (beta[-1] - beta[i]):
ans = max(ans, X)
break
print(ans)
| from itertools import accumulate
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = sum(A)
# 答えの候補を列挙
ans_candidates = []
for n in range(1, int(M ** 0.5) + 1):
if M % n == 0:
ans_candidates.append(n)
ans_candidates.append(M // n)
ans = 0
for X in ans_candidates:
A_mod = sorted([a % X for a in A])
U = [X - a for a in A_mod]
D = [-a for a in A_mod] # わかりやすいので
U = list(accumulate(U))
D = list(accumulate(D))
for i in range(N):
if -D[i] > K:
break
if -D[i] == (U[-1] - U[i]):
ans = max(ans, X)
break
print(ans)
| p02955 |
import math
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
tot = sum(A)
cand = helper(tot)
# print("here", cand)
for i in cand:
rems = []
for j in range(N):
r = A[j] % i
if r > 0:
rems.append(r)
rems.sort()
# print(rems)
tot = sum(rems)
prefixneg = [0]
for j in range(len(rems)):
prefixneg.append(prefixneg[-1] + rems[j])
# print(prefixneg)
for j in range(len(rems)+1):
pos = (len(rems)-j)*i - (tot - prefixneg[j])
neg = prefixneg[j]
# print(i, pos, neg)
if max(pos, neg) <= K:
return i
return 1
def helper(n):
div = set()
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
div.add(i)
div.add(n//i)
return sorted(list(div), reverse = True)
if __name__ == '__main__':
print((main())) | import math
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
tot = sum(A)
cand = helper(tot)
for i in cand:
rems = []
for j in range(N):
r = A[j] % i
if r > 0:
rems.append(r)
rems.sort()
tot = sum(rems)
prefixneg = [0]
for j in range(len(rems)):
prefixneg.append(prefixneg[-1] + rems[j])
for j in range(len(rems)+1):
pos = (len(rems)-j)*i - (tot - prefixneg[j])
neg = prefixneg[j]
if max(pos, neg) <= K:
return i
return 1
def helper(n):
div = set()
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
div.add(i)
div.add(n//i)
return sorted(list(div), reverse = True)
if __name__ == '__main__':
print((main())) | p02955 |
from heapq import heapify, heappush, heappop
def divisor(n):
divisors = []
i = 1
while i * i <= n:
if n % i == 0:
divisors.append(i)
if i != n / i:
divisors.append(n // i)
i += 1
divisors.sort()
return divisors
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
divisors = divisor(sum(A))
for d in divisors[::-1]:
heap = []
s = 0
for a in A:
x = a // d * d - a
heap.append(x)
s += -x
heapify(heap)
n = 0
for _ in range(s // d):
x = heappop(heap)
if x + d > K:
break
else:
if x + d > 0:
n += x + d
heappush(heap, x + d)
else:
if sum(abs(x) for x in heap) <= 2 * K:
print(d)
exit()
| def divisor(n):
divisors = []
i = 1
while i * i <= n:
if n % i == 0:
divisors.append(i)
if i * i < n:
divisors.append(n // i)
i += 1
divisors.sort()
return divisors
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
divisors = divisor(sum(A))
for d in divisors[::-1]:
rem = [a % d for a in A]
rem.sort(reverse=True)
i = sum(rem) // d
if sum(rem[i:]) <= K:
print(d)
exit()
| p02955 |
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
D = sum(A)
D = make_divisors(D)[::-1]
for d in D:
a = []
for i in range(N):
if A[i]%d != 0:
a.append(A[i]%d)
a.sort()
b = [d-x for x in a]
b.sort()
c1 = [0]*(len(a)+1)
for i in range(len(a)):
c1[i] = a[i]+c1[i-1]
c2 = [0]*(len(b)+1)
for i in range(len(b)):
c2[i] = b[i]+c2[i-1]
k = float('inf')
for i in range(len(a)):
if c1[i] == c2[len(a)-2-i]:
k = c1[i]
break
if k <= K:
break
print(d) | def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
D = sum(A)
D = make_divisors(D)[::-1]
for d in D:
a = []
for i in range(N):
a.append(A[i]%d)
k = 0
M = max(a)
while k <= K and M != 0:
i = 0
j = 0
m = d
M = 0
for l in range(N):
if 0 < a[l] < m:
m = a[l]
i = l
for l in range(N-1,-1,-1):
if a[l] > M:
M = a[l]
j = l
if m == d:
break
if m <= d-M:
a[i] = 0
a[j] += m
a[j] %= d
k += m
else:
a[i] -= d-M
a[i] %= d
a[j] = 0
k += d-M
if k <= K:
break
print(d) | p02955 |
N,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
sum_a=sum(alist)
alist.sort()
#print(sum_a,alist)
#M=1の場合にも対応
divisor_set=set()
for i in range(1,int(sum_a**0.5)+1):
if sum_a%i==0:
divisor_set.add(i)
divisor_set.add(sum_a//i)
divisor_list=list(divisor_set)
divisor_list.sort()
#print(divisor_list)
answer=0
for d in divisor_list:
rlist=[]
for a in alist:
rlist.append((a%d,(d-a%d)%d))
rlist.sort()
r1list,r2list=[],[]
for r1,r2 in rlist:
r1list.append(r1)
r2list.append(r2)
#print(d,r1list,r2list)
for i in range(len(rlist)):
r1sum=sum(r1list[:i])
r2sum=sum(r2list[i:])
if r1sum==r2sum and r1sum<=K:
answer=d
break
print(answer) | N,K=list(map(int,input().split()))
alist=list(map(int,input().split()))
sum_a=sum(alist)
alist.sort()
#print(sum_a,alist)
#M=1の場合にも対応
divisor_set=set()
for i in range(1,int(sum_a**0.5)+1):
if sum_a%i==0:
divisor_set.add(i)
divisor_set.add(sum_a//i)
divisor_list=list(divisor_set)
divisor_list.sort()
#print(divisor_list)
answer=0
for d in divisor_list:
rlist=[]
for a in alist:
rlist.append((a%d,(d-a%d)%d))
rlist.sort()
s1list,s2list=[0],[0]
for r1,r2 in rlist:
s1list.append(s1list[-1]+r1)
s2list.append(s2list[-1]+r2)
#print(d,s1list,s2list)
for i in range(len(rlist)):
r1sum=s1list[i]
r2sum=s2list[-1]-s2list[i]
if r1sum==r2sum and r1sum<=K:
answer=d
break
print(answer) | p02955 |
# -*- coding: utf-8 -*-
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return sorted(divisors, reverse=True)
if __name__ == '__main__':
n, k = list(map(int, input().split(' ')))
A = list(map(int, input().split(' ')))
divisors = make_divisors(sum(A))
for divisor in divisors:
remainders = sorted([x % divisor for x in A])
for i in range(1, n):
ope_num = max(sum(remainders[0:i]), sum([divisor - x for x in remainders[i:n]]))
if ope_num <= k:
print(divisor)
exit() | # -*- coding: utf-8 -*-
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return sorted(divisors, reverse=True)
if __name__ == '__main__':
n, k = list(map(int, input().split(' ')))
A = list(map(int, input().split(' ')))
divisors = make_divisors(sum(A))
for divisor in divisors:
remainders = sorted([x % divisor for x in A])
idx = n - sum(remainders) // divisor
ope_num = sum(remainders[:idx])
if ope_num <= k:
print(divisor)
break
| p02955 |
import sys
import math
n, k = map(int, input().split())
a = list(map(int, input().split()))
def ok(x):
b = []
for an in a:
b.append(an % x)
b.sort(reverse=True)
print(x, a, b, file=sys.stderr)
t = int(sum(b) / x)
print(t, sum(b[t:]), file=sys.stderr)
if t == 0:
return True
return True if sum(b[t:]) <= k else False
s = 0
for an in a:
s += an
ans = 1
for x in range(1, int(math.sqrt(s)) + 1):
if s % x != 0:
continue
if ok(x):
ans = max(ans, x)
if ok(int(s / x)):
ans = max(ans, int(s / x))
print(ans)
| import sys
import math
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
def ok(x):
b = [i % x for i in a]
b.sort(reverse=True)
t = int(sum(b) / x)
if t == 0:
return True
return True if sum(b[t:]) <= k else False
s = sum(a)
sqs = int(math.sqrt(s))
ans = 1
for x in range(1, sqs + 1):
if s % x != 0:
continue
if ok(x):
ans = max(ans, x)
if ok(int(s / x)):
ans = max(ans, int(s / x))
print(ans)
| p02955 |
# 約数の列挙
#############################################################
def make_divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n // i)
i += 1
return lower_divisors + upper_divisors[::-1]
#############################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
div_list = make_divisors(sum_A)
ans = 1
# print(div_list)
for div in div_list:
tmp = []
for a in A:
tmp.append(a % div)
tmp.sort()
cumsum1 = [0]
cumsum2 = [0]
for i in tmp:
cumsum1.append(cumsum1[-1] + i)
if i != 0:
cumsum2.append(cumsum2[-1] + (div - i))
else:
cumsum2.append(cumsum2[-1])
for i in range(1, N):
if cumsum1[i] <= K and cumsum2[N] - cumsum2[i] <= K:
ans = div
print(ans)
| import sys
input = sys.stdin.readline
# 約数の列挙
#############################################################
def make_divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n // i)
i += 1
return lower_divisors + upper_divisors[::-1]
#############################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 操作後も総和は変わらない
# 操作後にdivが公約数なら、divは総和の約数でもある
sum_A = sum(A)
div_list = make_divisors(sum_A)
ans = 1
for div in div_list:
# divで割った余りのリストをソート
# どこかを境に、左側は-1をして右側は+1をすると仮定する
tmp = [a % div for a in A]
tmp.sort()
# 累積和
cumsum1 = [0]
cumsum2 = [0]
for i in tmp:
cumsum1.append(cumsum1[-1] + i)
if i != 0:
cumsum2.append(cumsum2[-1] + (div - i))
else:
cumsum2.append(cumsum2[-1])
for i in range(1, N):
cnt_minus = cumsum1[i]
cnt_plus = cumsum2[N] - cumsum2[i]
# 条件を満たす時、必ずどこかで等しくなる
# （証明が理解できていないが、実験すると確かにそうなりそう）
if cnt_minus == cnt_plus and cnt_minus <= K:
ans = div
print(ans)
| p02955 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sumA = sum(A)
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
divisors = divisors[::-1]
return divisors
div = make_divisors(sumA)
#print(div)
for d in div:
tmp = []
for a in A:
tmp.append(a % d)
tmp.sort()
tmp = tmp[::-1]
sum_tmp = sum(tmp)
if sum(tmp[sum_tmp // d:]) <= K:
print(d)
exit() | import sys
input = sys.stdin.buffer.readline
def divisors(n) -> list:
res = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
res = sorted(res)[::-1]
return res
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
div = divisors(sum(A))
for d in div:
arr = []
for a in A:
if a % d != 0:
arr.append(d - a % d)
else:
arr.append(0)
arr = sorted(arr)[::-1]
tmp = sum(arr[sum(arr) // d:])
if tmp <= K:
print(d)
exit() | p02955 |
import math
import sys
def part_sum(a,A):
N=len(a)
dp=[[0 for i in range(A+1)] for j in range(N+1)]
dp[0][0]=1
for i in range(N):
for j in range(A+1):
if a[i]<=j:
dp[i+1][j]=dp[i][j-a[i]] or dp[i][j]
else:
dp[i+1][j]=dp[i][j]
return dp[N][A]
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
s=sum(a)
s_factors=[]
l=int(math.sqrt(s))
for i in range(1,l+1):
if s%i==0:
s_factors.append(i)
s_factors.append(s//i)
s_factors.sort()
for f in s_factors[::-1]:
b=[a[i]%f for i in range(n)]
c=[f-a[i]%f for i in range(n)]
b.sort()
c.sort()
c=c[::-1]
for i in range(n):
if sum(b[:i+1])==sum(c[i+1:]):
if sum(b[:i+1])<=k:
print(f)
sys.exit() | import math
import sys
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
s=sum(a)
s_factors=[]
l=int(math.sqrt(s))
for i in range(1,l+1):
if s%i==0:
s_factors.append(i)
s_factors.append(s//i)
s_factors.sort()
for f in s_factors[::-1]:
b=[a[i]%f for i in range(n)]
c=[f-a[i]%f for i in range(n)]
b.sort()
c.sort()
c=c[::-1]
sb=[0 for i in range(n)]
sc=[0 for i in range(n)]
sb[0]=b[0]
sc[0]=c[0]
for i in range(1,n):
sb[i]=sb[i-1]+b[i]
for i in range(1,n):
sc[i]=sc[i-1]+c[i]
for i in range(n):
if sb[i]==sc[n-1]-sc[i]:
if sb[i]<=k:
print(f)
sys.exit() | p02955 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n**0.5)+1):
if n % i == 0:
yield i
if i != n // i:
yield n // i
@mt
def slv(N, K, A):
S = sum(A)
D = [n for n in divisor(S)]
D.sort()
ans = 0
for d in D:
r = []
for a in A:
r.append(a % d)
r.sort()
rr = [d - n for n in r]
sr = [0]
srr = [0]
for i in range(N):
sr.append(sr[-1] + r[i])
srr.append(srr[-1] + rr[i])
for i in range(N):
e = sr[i+1] - sr[0]
f = srr[N]-srr[i+1]
if e == f and e <= K:
ans = max(ans, d)
break
return ans
def main():
N, K = read_int_n()
A = read_int_n()
print(slv(N, K, A))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def divisor(n):
for i in range(1, int(n**0.5)+1):
if n % i == 0:
yield i
if i != n // i:
yield n // i
@mt
def slv(N, K, A):
S = sum(A)
ans = 0
for d in divisor(S):
r = [a%d for a in A]
r.sort()
lr = [0]
rr = [0]
for v in r:
lr.append(lr[-1] + v)
rr.append(rr[-1] + (d-v))
for i in range(N):
l = lr[i+1] - lr[0]
r = rr[-1] - rr[i+1]
if l == r and l <= K:
ans = max(ans, d)
return ans
def main():
N, K = read_int_n()
A = read_int_n()
print(slv(N, K, A))
if __name__ == '__main__':
main()
| p02955 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
def distance(x,d):
r = x%d
return(min(r,d-r))
def cost(d,numList):
r = list([x%d for x in numList])
r.sort(reverse=True)
p = sum(r)//d
c = 0
for i in range(p):
c += d - r[i]
return(c)
def divisors(n):
sq = math.ceil(math.sqrt(n))
ans = []
for i in range(1,sq):
if n%i == 0:
ans.append(i)
ans.append(n//i)
return(ans)
s = sum(A)
divs = divisors(s)
ans = 1
for d in divs:
c = cost(d, A)
if c <= K:
ans = max(ans,d)
print(ans) | import math
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
def cost(d,numList):
r = [x%d for x in numList]
r.sort(reverse=True)
p = sum(r)//d
c = 0
for i in range(p):
c += d - r[i]
return(c)
def divisors(n):
sq = math.ceil(math.sqrt(n))
ans = []
for i in range(1,sq):
if n%i == 0:
ans.append(i)
ans.append(n//i)
return(ans)
divs = divisors(sum(A))
ans = 1
for d in divs:
c = cost(d, A)
if c <= K:
ans = max(ans,d)
print(ans) | p02955 |
from sys import stdin, setrecursionlimit
def main():
input = stdin.buffer.readline
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = sum(a)
cand = [s]
for i in range(2, int(s ** 0.5) + 1):
if s % i == 0:
cand.append(i)
cand.append(s // i)
cand.sort(reverse=True)
for c in cand:
arr = [[a[i] % c, a[i] % c - c] for i in range(n)]
min_sum = sum([ai[1] for ai in arr])
if (0 - min_sum) // c <= n:
for i in range(1 << n):
tmp = [0] * 2
for j in range(n):
if i & (1 << j):
tmp[0] += arr[j][0]
else:
tmp[1] += arr[j][1]
if sum(tmp) == 0 and tmp[0] <= k:
print(c)
exit()
print((1))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| from sys import stdin, setrecursionlimit
def main():
input = stdin.buffer.readline
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = sum(a)
cand = [s]
for i in range(2, int(s ** 0.5) + 1):
if s % i == 0:
cand.append(i)
cand.append(s // i)
cand.sort(reverse=True)
for c in cand:
arr = [a[i] % c for i in range(n)]
arr.sort()
sum_r = [0] * n
sum_r[0] = arr[0]
for i in range(1, n):
sum_r[i] = sum_r[i - 1] + arr[i]
for i in range(n - 1):
if sum_r[i] <= k:
sum_l = c * (n - i - 1) - sum_r[-1] + sum_r[i]
if sum_r[i] == sum_l:
print(c)
exit()
print((1))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| p02955 |
from heapq import heappush, heappop
N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
x = sum(A)
ls = []
for i in range(1, int(x**0.5)+1):
if x%i==0:
ls += [i]
if i != x//i:
ls += [x//i]
ls.sort(reverse=True)
for i in ls:
B =[]
for j in A:
heappush(B, -1*(j%i))
y = sum(B)
while y<0:
u = heappop(B)
u += i
heappush(B,u)
y += i
m = 0
for j in B:
if j>0:
m += j
if m>K:
continue
else:
print(i)
break
| N, K = list(map(int, input().split()))
A = [int(c) for c in input().split()]
S = sum(A)
pls = []
for i in range(1,S):
if i*i>S:
break
if S%i==0:
pls += [i]
pls += [S//i]
pls.sort(reverse=True)
for p in pls:
B = []
for i in range(N):
B += [A[i]%p]
B.sort()
for j in range(N):
if B[j]!=0:
break
m = j
lim = N-1
cnt = 0
while m<lim:
if B[m]<p-B[-1]:
B[-1] += B[m]
cnt += B[m]
B[m] = 0
m += 1
elif B[m]>p-B[-1]:
cnt += p-B[-1]
B[m] -= p-B[-1]
B.pop()
lim -= 1
else:
B.pop()
cnt += B[m]
B[m] = 0
m += 1
lim -= 1
if B[-1]==0 and cnt<=K:
print(p)
break | p02955 |
#### import ####
import sys
import math
from collections import defaultdict
#### 設定 ####
sys.setrecursionlimit(10**7)
#### 定数 ####
mod = 10**9 + 7
#### 読み込み ####
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort(reverse=True)
return divisors
N,K = II()
A = III()
sumA = sum(A)
kouho = make_divisors(sumA)
for i in kouho:
if sumA%i != 0:
continue
r = [0]*N
for j in range(N):
r[j] = A[j]%i
sumr = sum(r)
if sumr%i != 0:
continue
r.sort(reverse=True)
num = 0
for k in range(sumr//i):
num += i-r[k]
if num <= K:
print(i)
exit() | import sys
def input():
return sys.stdin.readline()[:-1]
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort(reverse=True)
return divisors
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
sumA = sum(A)
kouho = make_divisors(sumA)
for i in kouho:
if sumA%i != 0:
continue
r = [0]*N
for j in range(N):
r[j] = A[j]%i
sumr = sum(r)
if sumr%i != 0:
continue
r.sort(reverse=True)
num = 0
for k in range(sumr//i):
num += i-r[k]
if num <= K:
print(i)
exit() | p02955 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# nの約数を求める。計算量O(sqrt(N))
def get_divisors(n):
from math import sqrt, ceil
from collections import deque
divisors = deque([])
for num in range(ceil(sqrt(n)), n+1):
if n % num == 0:
divisors.append(n//num)
if n//num != n:
divisors.appendleft(num)
return list(divisors)
total = sum(A)
divisors = get_divisors(total)
ans = -1
for d in divisors:
R = [a%d for a in A]
R.sort(reverse=True)
pr = 0
nr = -sum(R)
for i, r in enumerate(R):
pr += d-r
nr += r
if nr+pr >= 0:
if pr <= K and nr+pr == 0:
ans = d
break
if ans != -1:
print(ans)
break
else:
print((1)) | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# nの約数を求める。計算量O(sqrt(N))
def get_divisors(n):
from math import sqrt, ceil
from collections import deque
divisors = deque([])
for num in range(ceil(sqrt(n)), n+1):
if n % num == 0:
divisors.append(n//num)
if n//num != n:
divisors.appendleft(num)
return list(divisors)
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n//i:
divisors.append(n//i)
divisors.sort(reverse=True)
return divisors
total = sum(A)
divisors = make_divisors(total)
ans = -1
for d in divisors:
R = [a%d for a in A]
R.sort(reverse=True)
pr = 0
nr = -sum(R)
for i, r in enumerate(R):
pr += d-r
nr += r
if nr+pr >= 0:
if pr <= K and nr+pr == 0:
ans = d
break
if ans != -1:
print(ans)
break
else:
print((1))
| p02955 |
n,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
s=sum(a)
candidates=set()
for i in range(1,int(s**0.5)+2):
if s%i==0:
candidates.add(i)
candidates.add(s//i)
ans=0
for cdd in candidates:
div_cdd=[0]*n
for i in range(n):
div_cdd[i]=a[i]%cdd
div_cdd=sorted(div_cdd)
pstv,ngtv=0,-sum(div_cdd)
# calc need
if pstv==-ngtv:
ans=max(ans,cdd)
continue
for i in range(n):
pstv+=cdd-div_cdd[-1-i]
ngtv+=div_cdd[-1-i]
if pstv==-ngtv: break
ans=max(ans,cdd) if pstv<=k else ans
print(ans) | n,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
s=sum(a)
candidates=set()
for i in range(1,int(s**0.5)+1):
if s%i==0:
candidates.add(i)
candidates.add(s//i)
ans=0
for cdd in candidates:
div_cdd=[0]*n
for i in range(n):
div_cdd[i]=a[i]%cdd
div_cdd=sorted(div_cdd)
pstv,ngtv=0,-sum(div_cdd)
# calc need
if pstv==-ngtv:
ans=max(ans,cdd)
continue
for i in range(n):
pstv+=cdd-div_cdd[-1-i]
ngtv+=div_cdd[-1-i]
if pstv==-ngtv: break
ans=max(ans,cdd) if pstv<=k else ans
print(ans) | p02955 |
n,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
s=sum(a)
candidates=set()
for i in range(1,int(s**0.5)+1):
if s%i==0:
candidates.add(i)
candidates.add(s//i)
ans=0
for cdd in candidates:
div_cdd=[0]*n
for i in range(n):
div_cdd[i]=a[i]%cdd
div_cdd=sorted(div_cdd)
pstv,ngtv=0,-sum(div_cdd)
# calc need
if pstv==-ngtv:
ans=max(ans,cdd)
continue
for i in range(n):
pstv+=cdd-div_cdd[-1-i]
ngtv+=div_cdd[-1-i]
if pstv==-ngtv: break
ans=max(ans,cdd) if pstv<=k else ans
print(ans) | n,k=list(map(int,input().split()))
a=[int(x) for x in input().split()]
s=sum(a)
candidates=set()
for i in range(1,int(s**0.5)+1):
if s%i==0:
candidates.add(i)
candidates.add(s//i)
ans=0
for cdd in candidates:
div_cdd=[0]*n
for i in range(n):
div_cdd[i]=a[i]%cdd
div_cdd=sorted(div_cdd)
# calc need
idx=n-sum(div_cdd)//cdd
need=0
for i in range(idx):
need+=div_cdd[i]
ans=max(ans,cdd) if need<=k else ans
print(ans) | p02955 |
words = lambda t : list(map(t, input().split()))
n,k = words(int)
xs = words(int)
def divisor (x):
ans = [1]
for i in range(2, x//2+1):
if x % i == 0:
ans.append(i)
ans.append(x)
return list(reversed(ans))
s = sum(xs)
ds = divisor(s)
ans = 1
#print(ds)
for d in ds:
ms = []
for x in xs:
ms.append(x%d)
ms.sort()
#print(d,ms)
f = 0
f_ttl = ms[f]
b = len(ms)-1
b_ttl = d - ms[b]
while f != b:
if f_ttl >= b_ttl:
b -= 1
b_ttl += d - ms[b]
else:
f += 1
f_ttl += ms[f]
if k >= f_ttl:
ans = d
break
print(ans)
| words = lambda t : list(map(t, input().split()))
n,k = words(int)
xs = words(int)
def divisor (x):
ans = []
for i in range(1, int(x**0.5)+1):
if x % i == 0:
ans.append(i)
if i != x // i:
ans.append(x//i)
ans.sort()
return list(reversed(ans))
s = sum(xs)
#print(s)
ds = divisor(s)
ans = 1
#print(ds)
for d in ds:
ms = []
for x in xs:
ms.append(x%d)
ms.sort()
#print(d,ms)
f = 0
f_ttl = ms[f]
b = len(ms)-1
b_ttl = d - ms[b]
while f != b:
if f_ttl >= b_ttl:
b -= 1
b_ttl += d - ms[b]
else:
f += 1
f_ttl += ms[f]
if k >= f_ttl:
ans = d
break
print(ans)
| p02955 |
# -*- coding: utf-8 -*-
import sys
from math import sqrt
from collections import deque
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N,K=MAP()
A=LIST()
sm=sum(A)
def divisor_set(N: int) -> set:
""" 約数の列挙・個数 """
# 1とその数はデフォで入れとく
s = {1, N}
# 終点はルート切り捨て
for i in range(2, int(sqrt(N))+1):
# 割り切れるなら、iとN/iを追加
if N % i == 0:
s.add(i)
s.add(N // i)
return s
divs=sorted(divisor_set(sm), reverse=True)
for div in divs:
B=[]
for i in range(N):
if A[i]%div!=0:
B.append(A[i]%div)
B.sort()
B=deque(B)
cnt=0
while len(B):
B[0]-=1
B[-1]+=1
if B[0]%div==0:
B.popleft()
if B[-1]%div==0:
B.pop()
cnt+=1
if cnt<=K:
print(div)
exit()
| # -*- coding: utf-8 -*-
import sys
from math import sqrt
from collections import deque
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N,K=MAP()
A=LIST()
sm=sum(A)
def divisor_set(N: int) -> set:
""" 約数の列挙・個数 """
# 1とその数はデフォで入れとく
s = {1, N}
# 終点はルート切り捨て
for i in range(2, int(sqrt(N))+1):
# 割り切れるなら、iとN/iを追加
if N % i == 0:
s.add(i)
s.add(N // i)
return s
divs=sorted(divisor_set(sm), reverse=True)
for div in divs:
B=[]
for i in range(N):
if A[i]%div!=0:
B.append(A[i]%div)
# mod取ったものをソート、これを前後からdivの約数に合わせていく
B.sort()
B=deque(B)
cnt=0
while len(B):
# 先頭を引いていってdivの約数になるまでの距離
dista=B[0]%div
# 末尾を足していってdivの約数になるまでの距離
distb=div-B[-1]%div
# どちらが近いかに応じてリストBを操作する
if dista>distb:
B[0]-=distb
B.pop()
cnt+=distb
elif dista<distb:
B[-1]+=dista
B.popleft()
cnt+=dista
elif dista==distb:
B.pop()
B.popleft()
cnt+=dista
# 操作回数がK回以内ならOK
if cnt<=K:
print(div)
exit()
| p02955 |
def solve():
N,K = list(map(int , input().split()))
A = list(map(int , input().split()))
max_A = max(A)
total = sum(A)
# ave_region = total//N
max_d = 1
for d in A:
if all(a%d==0 for a in A) and d > max_d:
max_d = d
if K >= total:
max_d = total
search_region = list(range(max_d, min(total, max_A+K)+1))
for d in search_region:
if total % d == 0:
remainders = [a%d for a in A]
remainders = sorted(remainders)
# print(d, remainders)
positive_rem = 0
negative_rem = 0
flag = True
for rem in remainders:
if positive_rem+rem <= K:
positive_rem += rem
elif negative_rem+(d-rem) <=K:
negative_rem += (d-rem)
else:
flag = False
break
if flag :
# print(d, remainders, positive_rem, negative_rem)
max_d = d
print(max_d)
solve() | def solve():
N,K = list(map(int , input().split()))
A = list(map(int , input().split()))
max_total = 22361 # sqrt(10**6 * 500)
total = sum(A)
search_space = set([])
max_d = 1
for d in range(1, min(total, max_total) ):
if total % d == 0:
search_space.add(d)
search_space.add(total // d)
# print(search_space)
for d in search_space:
if total % d == 0:
remainders = [a%d for a in A]
remainders = sorted(remainders)
# print(d, remainders)
positive_rem = 0
negative_rem = 0
flag = True
for rem in remainders:
if positive_rem+rem <= K:
positive_rem += rem
elif negative_rem+(d-rem) <=K:
negative_rem += (d-rem)
else:
flag = False
break
if flag and d > max_d:
# print(d, remainders, positive_rem, negative_rem)
max_d = d
print(max_d)
solve() | p02955 |
def solve():
N,K = list(map(int , input().split()))
A = list(map(int , input().split()))
max_total = 22361 # sqrt(10**6 * 500)
total = sum(A)
search_space = set([])
max_d = 1
for d in range(1, min(total, max_total) ):
if total % d == 0:
search_space.add(d)
search_space.add(total // d)
# print(search_space)
for d in search_space:
if total % d == 0:
remainders = [a%d for a in A]
remainders = sorted(remainders)
# print(d, remainders)
positive_rem = 0
negative_rem = 0
flag = True
for rem in remainders:
if positive_rem+rem <= K:
positive_rem += rem
elif negative_rem+(d-rem) <=K:
negative_rem += (d-rem)
else:
flag = False
break
if flag and d > max_d:
# print(d, remainders, positive_rem, negative_rem)
max_d = d
print(max_d)
solve() | def get_divisor(num, max_val):
ret = []
num_sq = int(num**0.5)
for k in range(1, num_sq+1):
if num % k == 0:
if k <= max_val: ret.append(k)
if num//k <= max_val: ret.append(num//k)
return ret
# 下からmodが低いのを取ってきてマッチングを取る
def solve():
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
max_A = max(A)
div = get_divisor(sum_A, max_A+K)
ret = 1
for d in div:
sum_k = 0
red_k = 0
flag = True
mod_d = [a%d for a in A]
mod_d.sort()
# print(d, mod_d)
for a in mod_d:
if sum_k+a <= K:
sum_k += a
else:
red_k += d-a
if sum_k-red_k < 0:
break
if (sum_k-red_k)%d == 0: ret = max(ret, d)
print(ret)
solve() | p02955 |
import sys, math
from collections import defaultdict
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, K = rl()
A = rl()
s = sum(A)
m = math.ceil(math.sqrt(s))
divs = []
divs2 = []
i = 1
while i < s:
if s % i == 0:
divs.append(i)
divs2.append(s//i)
i += 1
divs.reverse()
divs2 += divs
ans = 1
for n in divs2:
B = [a % n for a in A]
s = sum(B)
if s % n != 0: continue
B.sort()
B = [b for b in B if b != 0]
if len(B) == 0:
ans = max(ans, n)
break
bsum = [0]*len(B)
rbsum = [0]*len(B)
bs = 0
for i, b in enumerate(B):
bs += b
bsum[i] = bs
bs = 0
for i, b in reversed(list(enumerate(B))):
bs += n - b
rbsum[i] = bs
need = float('inf')
for i in range(len(B)-1):
if bsum[i] == rbsum[i+1]:
need = bsum[i]
break
if need <= K:
ans = max(ans, n)
break
print(ans)
| import sys, math
from collections import defaultdict
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, K = rl()
A = rl()
s = sum(A)
m = math.ceil(math.sqrt(s))
divs = []
divs2 = []
i = 1
while i <= m:
if s % i == 0:
divs.append(i)
divs2.append(s//i)
i += 1
divs.reverse()
divs2 += divs
ans = 1
for n in divs2:
B = [a % n for a in A]
s = sum(B)
if s % n != 0: continue
B.sort()
B = [b for b in B if b != 0]
if len(B) == 0:
ans = max(ans, n)
break
bsum = [0]*len(B)
rbsum = [0]*len(B)
bs = 0
for i, b in enumerate(B):
bs += b
bsum[i] = bs
bs = 0
for i in range(len(B)-1, -1, -1):
bs += n - B[i]
rbsum[i] = bs
need = float('inf')
for i in range(len(B)-1):
if bsum[i] == rbsum[i+1]:
need = bsum[i]
break
if need <= K:
ans = max(ans, n)
break
print(ans)
| p02955 |
from itertools import accumulate
def divisors(N):
U = int(N ** 0.5) + 1
L = [i for i in range(1, U) if N % i == 0]
return L + [N // i for i in reversed(L) if N != i * i]
N, K, *A = list(map(int, open(0).read().split()))
for d in reversed(divisors(sum(A))):
R = [0] + list(accumulate(sorted(a % d for a in A)))
for i in range(N):
l = R[i]
r = (N - i) * d - (R[N] - R[i])
if max(l, r) <= K:
print(d)
quit()
| def divisors(N):
U = int(N ** 0.5) + 1
L = [i for i in range(1, U) if N % i == 0]
return L + [N // i for i in reversed(L) if N != i * i]
N, K, *A = list(map(int, open(0).read().split()))
for d in reversed(divisors(sum(A))):
R = sorted(a % d for a in A)
if sum(R[:-sum(R) // d]) <= K:
print(d)
quit()
| p02955 |
def divisors(N):
U = int(N ** 0.5) + 1
L = [i for i in range(1, U) if N % i == 0]
return L + [N // i for i in reversed(L) if N != i * i]
N, K, *A = list(map(int, open(0).read().split()))
for d in reversed(divisors(sum(A))):
R = sorted(a % d for a in A)
if sum(R[:-sum(R) // d]) <= K:
print(d)
quit()
| def divisors(N):
U = int(N ** 0.5) + 1
L = [i for i in range(1, U) if N % i == 0]
return L + [N // i for i in reversed(L) if N != i * i]
def main():
N, K, *A = list(map(int, open(0).read().split()))
for d in reversed(divisors(sum(A))):
R = sorted(a % d for a in A)
if sum(R[:-sum(R) // d]) <= K:
print(d)
quit()
if __name__ == '__main__':
main() | p02955 |
import sys
import math
MAX_INT = int(10e9)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
def judge(x):
l = []
for i in range(N):
l.append(a[i]%x)
l.sort()
aa = 0
bb = 0
for i in l:
tmp = i
if aa + tmp > K:
bb += x-tmp
if bb > K:
return False
else:
aa += tmp
else:
return True
N,K = IL()
a = IL()
num = sum(a)
ans = []
for i in range(num,int(math.sqrt(num)-1),-1):
if num%i == 0:
if judge(i):
print(i)
exit()
if judge(num//i):
ans.append(num//i)
print((max(ans))) | import sys
import math
MAX_INT = int(10e9)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
def judge(x):
l = []
for i in range(N):
l.append(a[i]%x)
l.sort()
aa = 0
bb = 0
for i in l:
tmp = i
if aa + tmp > K:
bb += x-tmp
if bb > K:
return False
else:
aa += tmp
else:
return True
N,K = IL()
a = IL()
num = sum(a)
ans = []
for i in range(1,int(math.sqrt(num)+1)):
if num%i == 0:
if judge(i):
ans.append(i)
if judge(num//i):
ans.append(num//i)
print((max(ans))) | p02955 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,k = inpl()
a = inpl()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort(reverse = True)
return divisors
pr = make_divisors(sum(a))
def sol(p):
mo = []
pl = []
for i in a:
if i%p != 0:
mo += [i%p]
pl += [p-i%p]
mo.sort(); pl.sort()
m = 0; c = sum(pl)
ln = len(mo)
for i in range(ln):
m += mo[i]
c -= pl[ln-i-1]
if max(m,c) <= k and m == c:
return True
return False
for p in pr:
if sol(p):
res = p
break
else:
res = 1
print(res)
| from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,k = inpl()
a = inpl()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort(reverse = True)
return divisors
pr = make_divisors(sum(a))
def sol(p):
mo = []
pl = []
for i in a:
if i%p != 0:
mo += [i%p]
pl += [p-i%p]
mo.sort(); pl.sort()
m = 0; c = sum(pl)
ln = len(mo)
for i in range(ln):
m += mo[i]
c -= pl[ln-i-1]
if max(m,c) <= k and m%p == c%p:
return True
return False
for p in pr:
if sol(p):
res = p
break
else:
res = 1
print(res)
| p02955 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sumA = sum(A)
divisors = []
for i in range(1, sumA + 1):
if i * i > sumA:
break
if sumA % i != 0:
continue
divisors.append(i)
if sumA // i != i:
divisors.append(sumA // i)
divisors.sort(reverse=True)
ans = 0
for d in divisors:
costs = [a % d for a in A]
costs.sort(reverse=True)
plus = sum(costs)
minus = 0
for j in range(N):
if plus == minus:
break
else:
plus -= costs[j]
minus += d - costs[j]
if plus <= K:
print(d)
break | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sumA = sum(A)
divisors = []
for i in range(1, sumA + 1):
if i * i > sumA:
break
if sumA % i != 0:
continue
divisors.append(i)
if sumA // i != i:
divisors.append(sumA // i)
divisors.sort(reverse=True)
for d in divisors:
# 一旦全部マイナス方向に調整することにしたら総和はXの倍数になる
# どれか一つ符号を逆転すると総和がx減るので、総和/d番目が境目になる
# A = [8, 20]
# d = 7
# costs = [1, 6]
# 20をプラス方向に調整することにすると、マイナス方向の調整は6減ってプラス方向に(7 - 1)増える
# 1個をマイナス方向をプラス方向に変更すると、マイナス方向のコストの総和の差とプラス方向のコストの総和の差がdだけ詰まる
# よって、最初全部マイナス方向に調整したときのコストの総和7を7で割ったところが境目
# プラス方向にはcostが大きい方から変更したい(調整の量が少なくてすむ)ので、最初にソートしておく
costs = [a % d for a in A]
costs.sort(reverse=True)
if sum(costs[sum(costs) // d:]) <= K:
print(d)
break
| p02955 |
import sys
import copy
input = sys.stdin.readline
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
x=sum(A)
import math
xr=math.ceil(math.sqrt(x))
LIST=[]
for i in range(1,xr+1):
if x%i==0:
LIST.append(i)
LIST.append(x//i)
MIN=0
MAX=sum(A)
ANS=1
A.sort()
for l in LIST:
count=0
B=[a%l for a in A]
B.sort()
i=0
j=N-1
for i in range(N):
if B[i]%l==0:
continue
else:
count_temp=0
while B[i]%l!=0:
B[i]-=1
count_temp+=1
for t in range(count_temp):
while B[j]%l==0:
j-=1
B[j]+=1
count+=count_temp
if count<=K:
ANS=max(ANS,l)
print(ANS)
| import sys
input = sys.stdin.readline
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
x=sum(A)
import math
xr=math.ceil(math.sqrt(x))
LIST=[]
for i in range(1,xr+1):
if x%i==0:
LIST.append(i)
LIST.append(x//i)
ANS=1
for l in LIST:
count=0
B=[a%l for a in A]
B.sort()
i=0
j=N-1
for i in range(N):
if B[i]%l==0:
continue
else:
count_temp=B[i]
count+=count_temp
B[i]=0
while count_temp:
while B[j]%l==0:
j-=1
MINUS=min(count_temp,l-B[j])
B[j]+=MINUS
count_temp-=MINUS
if count<=K:
ANS=max(ANS,l)
print(ANS)
| p02955 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
import math
Asum = sum(A)
candidates = []
for i in range(1, int(math.sqrt(Asum)) + 1):
if Asum % i == 0:
candidates.append(i)
candidates.append(Asum // i)
candidates.sort()
# print("#", Asum)
# print("#", candidates)
ans = 1
for targ in candidates:
if targ == 1: continue
A_tmp = [(Ai % targ) for Ai in A]
# A_tmp.sort(key=lambda x: min((x % targ), ((targ - x) % x)))
A_tmp.sort()
idx_l = 0
idx_r = N - 1
cnt = 0
while sum(A_tmp) > 0:
cap_l = A_tmp[idx_l]
cap_r = targ - A_tmp[idx_r]
A_tmp[idx_l] = (A_tmp[idx_l] - min(cap_l, cap_r)) % targ
A_tmp[idx_r] = (A_tmp[idx_r] + min(cap_l, cap_r)) % targ
cnt += min(cap_l, cap_r)
if A_tmp[idx_l] == 0:
idx_l += 1
if A_tmp[idx_r] == 0:
idx_r -= 1
#
if cnt <= K: ans = targ
print(ans) | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
import math
Asum = sum(A)
candidates = []
for i in range(1, int(math.sqrt(Asum)) + 1):
if Asum % i == 0:
candidates.append(i)
candidates.append(Asum // i)
candidates.sort()
# print("#", Asum)
# print("#", candidates)
ans = 1
for targ in candidates:
if targ == 1: continue
A_tmp = [(Ai % targ) for Ai in A]
# A_tmp.sort(key=lambda x: min((x % targ), ((targ - x) % x)))
A_tmp.sort()
idx_l = 0
idx_r = N - 1
cnt = 0
while sum(A_tmp) > 0 and idx_l < idx_r:
cap_l = A_tmp[idx_l]
cap_r = targ - A_tmp[idx_r]
A_tmp[idx_l] = (A_tmp[idx_l] - min(cap_l, cap_r)) % targ
A_tmp[idx_r] = (A_tmp[idx_r] + min(cap_l, cap_r)) % targ
cnt += min(cap_l, cap_r)
if A_tmp[idx_l] == 0:
idx_l += 1
if A_tmp[idx_r] == 0:
idx_r -= 1
#
if cnt <= K and sum(A_tmp) == 0: ans = targ
print(ans) | p02955 |
n,k,*a=list(map(int,open(0).read().split()))
s,m=sum(a),1
for i in sum([[s//i,i]for i in range(1,int(s**.5)+1)if s%i<1],[]):
p=[0]+sorted(j%i for j in a)
for j in range(n):p[j+1]+=p[j]
f=t=0
for j in range(n):
f|=t==p[~j]<=k
t+=i-p[~j]+p[-j-2]
m=max(m,i*f)
print(m) | n,k,*a=list(map(int,open(0).read().split()))
s=sum(a)
b=[]
for i in range(1,int(s**.5)+1):b+=[s//i,i]*(s%i<1)
m=1
for i in b:c=sorted(j%i for j in a);m=max(m,i*(sum(c[:-sum(c)//i])<=k))
print(m) | p02955 |
# E
import sys
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = sum(a)
for p in range(1,s+1) :
if s % p != 0:
continue
b = s // p
r1 = [x % b for x in a]
r1.sort()
s1 = sum(r1)
mn = 1e9
s2 = 0
for i in range(n):
s2 += r1[i]
mn = min(max(s2, (n-1-i)*b - (s1-s2)), mn)
if mn <= k :
print((int(b)))
sys.exit(0)
| # E
import sys
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = sum(a)
l = []
def check(b) :
r1 = [x % b for x in a]
r1.sort()
s1 = sum(r1)
mn = 1e9
s2 = 0
for i in range(n):
s2 += r1[i]
mn = min(max(s2, (n-1-i)*b - (s1-s2)), mn)
if mn <= k :
print((int(b)))
sys.exit(0)
for p in range(1,int((s+1)**0.5+1)) :
if s % p != 0:
continue
b = s // p
l.append(b)
check(b)
l.reverse()
for p in l:
b = s // p
check(b)
| p02955 |
N, K = list(map(int, input().split()))
a_list = list(map(int, input().split()))
total_a = sum(a_list)
#約数の列挙
candidates = set()
for i in [a for a in range(1, total_a) if a * a <= total_a]:
if total_a % i == 0:
candidates.add(i)
candidates.add(total_a // i)
ans = 1
for x in candidates:
remainders = sorted([a % x for a in a_list])
total_r = sum(remainders)
border = total_r // x
need = sum(remainders[:(N - border)])
if need <= K:
ans = max(ans, x)
print(ans)
| N, K = list(map(int, input().split()))
a_list = list(map(int, input().split()))
total_a = sum(a_list)
#約数の列挙
candidates = set()
for i in range(1, total_a):
if i * i > total_a:
break
if total_a % i == 0:
candidates.add(i)
candidates.add(total_a // i)
ans = 1
for x in candidates:
remainders = sorted([a % x for a in a_list])
total_r = sum(remainders)
border = total_r // x
need = sum(remainders[:(N - border)])
if need <= K:
ans = max(ans, x)
print(ans)
| p02955 |
from math import sqrt
from itertools import accumulate
def common_divisors(x):
ret = []
for i in range(1, int(sqrt(x)) + 1):
if x % i == 0:
ret.append(i)
ret.append(x // i)
return ret
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
cd = common_divisors(sm)
ans = 1
for ecd in cd:
r = [e % ecd for e in a]
r.sort()
acc = [0] + list(accumulate(r))
for i in range(1, n + 1):
sub = acc[i-1]
add = ecd * (n - i + 1) - (acc[n] - acc[i-1])
if sub == add:
if sub <= k:
ans = max(ans, ecd)
print(ans)
| from math import sqrt
from itertools import accumulate
def common_divisors(x):
ret = []
for i in range(1, int(sqrt(x)) + 1):
if x % i == 0:
ret.append(i)
ret.append(x // i)
return ret
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
cd = common_divisors(sm)
ans = 1
for ecd in cd:
r = [e % ecd for e in a]
r.sort()
sub = [0] + list(accumulate(r))
add = [0] + list(accumulate(ecd - e for e in r[::-1]))
add = add[::-1]
for sb, ad in zip(sub, add):
if sb == ad and sb <= k:
ans = max(ans, ecd)
print(ans)
| p02955 |
from math import sqrt
from itertools import accumulate
def common_divisors(x):
ret = []
for i in range(1, int(sqrt(x)) + 1):
if x % i == 0:
ret.append(i)
ret.append(x // i)
return ret
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
cd = common_divisors(sm)
ans = 0
for ecd in cd:
r = [e % ecd for e in a]
r.sort()
sub = [0] + list(accumulate(r))
add = [0] + list(accumulate(ecd - e for e in r[::-1]))
add = add[::-1]
for sb, ad in zip(sub, add):
if sb == ad and sb <= k:
ans = max(ans, ecd)
print(ans)
| def get_divisors(x):
i = 1
ret = set()
while i * i <= x:
if x % i == 0:
ret.add(i)
ret.add(x // i)
i += 1
return ret
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
divs = get_divisors(sm)
ans = 0
for div in divs:
mods = [e % div for e in a]
mods.sort()
p = 0
m = n * div - sum(mods)
for mod in mods:
p += mod
m -= div - mod
if p == m:
if p <= k:
ans = max(ans, div)
break
print(ans)
| p02955 |
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(eval(input()))
def FLIST(n):
res = [1]
for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
return res
def gcd(x, y):
if x < y: x, y = y, x
div = x % y
while div != 0:
x, y = y, div
div = x % y
return y
N,K=LI()
AS=LI()
SUMM= sum(AS)
DIVS=set()
for i in range(1,40000):
if SUMM % i == 0:
DIVS.add(i)
DIVS.add(SUMM//i)
# DIVS.sort(reversed=True)
# print(DIVS)
DIFF=[0]*N
ACC=[0]*N
# res = 0
for div in sorted(DIVS, reverse=True):
for i in range(N):
DIFF[i] = AS[i]%div
DIFF.sort()
ACC[0] = DIFF[0]
for i in range(1,N): ACC[i] = ACC[i-1] + DIFF[i]
# print(ACC)
for i in range(N-1):
left = ACC[i]
right = (N-1-i)*div-(ACC[N-1]-ACC[i])
if left%div == right%div:
if max(left, right) <= K:
# print(max(left, right))
print(div)
exit()
# print(DIFF)
# print(res)
| import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(eval(input()))
def FLIST(n):
res = [1]
for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
return res
def gcd(x, y):
if x < y: x, y = y, x
div = x % y
while div != 0:
x, y = y, div
div = x % y
return y
N,K=LI()
AS=LI()
SUMM= sum(AS)
DIVS=set()
for i in range(1,40000):
if SUMM % i == 0:
DIVS.add(i)
DIVS.add(SUMM//i)
# print(DIVS)
DIFF=[0]*N
res = 0
for div in DIVS:
for i in range(N):
DIFF[i] = AS[i]%div
DIFF.sort()
i = 0
j = N-1
sm = 0
cost = 0
while i <= j:
if sm + DIFF[j] >= div:
sm -= (div - DIFF[j])
j -= 1
else:
cost += DIFF[i]
sm += DIFF[i]
i += 1
# print("div:{} sum: {} cost: {}".format(div, sm, cost))
if cost <= K: res = max(res, div)
# print(DIFF)
print(res)
| p02955 |
from collections import deque
def isok(x):
que=deque(sorted(z%x for z in a))
res=0
while que:
l=que[0]
if l==0:
que.popleft()
continue
r=que[-1]
if r==0:
que.pop()
continue
d=min(l,x-r)
que[0]-=d
que[-1]=(que[-1]+d)%x
res+=d
return res
def factor(N):
arr=[]
for i in range(1,int(N**0.5)+1):
if(N%i==0):
arr.append(i)
if(N//i!=i):
arr.append(N//i)
return arr
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
sum_=sum(a)
fac=sorted(factor(sum_),reverse=True)
ans=1
for x in fac:
c=isok(x)
if c<=k:
ans=x
break
print(ans)
| def factor(N):
arr=[]
for i in range(1,int(N**0.5)+1):
if(N%i==0):
arr.append(i)
if(N//i!=i):
arr.append(N//i)
return arr
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
sum_=sum(a)
fac=sorted(factor(sum_),reverse=True)
ans=1
for x in fac:
li=sorted(z%x for z in a)
res=0
cum=[0]*(n+1)
for i in range(n):
cum[i+1]=cum[i]+li[i]
for i in range(1,n):
l,r=cum[i],x*(n-i)-(cum[n]-cum[i])
if l==r and r<=k:
ans=max(ans,x)
print(ans) | p02955 |
# 割り切る数は、Aの総和の約数である
# 自分自身を除く約数について大きい順にすべて試して、当てはまるものがあれば答え
# 8,20を7の倍数に近づけるとき、
# 8 -> mod 7が1であり、-1か+6で7の倍数になる
# 20 -> mod 7が6であり、-6か+1で7の倍数になる
# -1と+1をペアにすることが出来て、この操作回数1をK = 3から引くと2となり、これが偶数ならOK
import sys
readline = sys.stdin.readline
N,K = list(map(int,readline().split()))
A = list(map(int,readline().split()))
all = sum(A)
divisors = []
for i in range(1,int(all ** 0.5) + 1):
if all % i == 0:
divisors.append(i)
divisors.append(all // i)
divisors = sorted(divisors,reverse = True)
#print(divisors)
for d in divisors:
mods = [0] * (N)
for i in range(len(A)):
mods[i] = A[i] % d
mods = sorted(mods)
#print("d",d,"mods",mods)
mods_front = [0] * N
mods_front[0] = mods[0]
for i in range(1,N):
mods_front[i] = mods_front[i - 1] + mods[i]
mods_back = [0] * N
mods_back[-1] = d - mods[-1]
#print("mods_front",mods_front)
for i in range(N - 2,-1,-1):
mods_back[i] = mods_back[i + 1] + (d - mods[i])
#print("mods_back",mods_back)
for i in range(N - 1):
if mods_front[i] == mods_back[i + 1]:
if K >= min(mods_front[i],mods_back[i + 1]):
print(d)
exit(0)
else:
print((1)) | # 割り切る数は、Aの総和の約数である
# 自分自身を除く約数について大きい順にすべて試して、当てはまるものがあれば答え
# 8,20を7の倍数に近づけるとき、
# 8 -> mod 7が1であり、-1か+6で7の倍数になる
# 20 -> mod 7が6であり、-6か+1で7の倍数になる
import sys
readline = sys.stdin.readline
N,K = list(map(int,readline().split()))
A = list(map(int,readline().split()))
all = sum(A)
divisors = []
for i in range(1,int(all ** 0.5) + 1):
if all % i == 0:
divisors.append(i)
divisors.append(all // i)
divisors = sorted(divisors,reverse = True)
for d in divisors:
mods = [0] * (N)
for i in range(len(A)):
mods[i] = A[i] % d
mods = sorted(mods)
mods_front = [0] * N
mods_front[0] = mods[0]
for i in range(1,N):
mods_front[i] = mods_front[i - 1] + mods[i]
mods_back = [0] * N
mods_back[-1] = d - mods[-1]
for i in range(N - 2,-1,-1):
mods_back[i] = mods_back[i + 1] + (d - mods[i])
for i in range(N - 1):
if mods_front[i] == mods_back[i + 1]:
if K >= mods_front[i]:
print(d)
exit(0)
else:
print((1)) | p02955 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def divisors(n):
lower = []
upper = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
lower.extend(reversed(upper))
return lower
def main():
N, K, *A = list(map(int, read().split()))
total = sum(A)
div = divisors(total)
for d in reversed(div):
vec = [a % d for a in A if a % d]
if not vec:
print(d)
return
vec.sort()
M = len(vec)
csum_sub = [0] * (M + 1)
csum_add = [0] * (M + 1)
for i in range(M):
csum_sub[i + 1] = csum_sub[i] + vec[i]
csum_add[i + 1] = csum_add[i] + d - vec[i]
for i in range(1, M):
if csum_sub[i] <= K and csum_sub[i] == csum_add[M] - csum_add[i]:
print(d)
return
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def divisors(n):
lower = []
upper = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
lower.extend(reversed(upper))
return lower
def main():
N, K, *A = list(map(int, read().split()))
total = sum(A)
div = divisors(total)
for d in reversed(div):
vec = [a % d for a in A]
vec.sort()
M = len(vec)
csum_sub = [0] * (M + 1)
csum_add = [0] * (M + 1)
for i in range(M):
csum_sub[i + 1] = csum_sub[i] + vec[i]
csum_add[i + 1] = csum_add[i] + d - vec[i]
for i in range(M + 1):
if csum_sub[i] <= K and csum_sub[i] == csum_add[M] - csum_add[i]:
print(d)
return
return
if __name__ == '__main__':
main()
| p02955 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
Asum = sum(A)
div = set()
for i in range(1, int(Asum ** 0.5 + 0.5) + 1):
if Asum % i == 0:
div.add(i)
div.add(Asum//i)
ans = 1
for d in div:
now = 10 ** 18
R = [a % d for a in A]
R.sort()
Rsum = sum(d - r for r in R)
Lsum = 0
for r in R:
Lsum += r
Rsum -= d - r
now = min(now, max(Lsum, Rsum))
if now <= K:
ans = max(ans, d)
print(ans)
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
Asum = sum(A)
div = set()
for i in range(1, int(Asum ** 0.5 + 0.5) + 1):
if Asum % i == 0:
div.add(i)
div.add(Asum//i)
ans = 1
for d in div:
R = [a % d for a in A]
R.sort()
r = sum(R) // d
l = N - r
need = sum(R[:l])
if need <= K:
ans = max(ans, d)
print(ans)
| p02955 |
inp = list([int(x) for x in input().split(" ")])
N = inp[0]
M = inp[1]
dp = [-1]*N
g = {}
def path(x):
if dp[x-1]!=-1:
return dp[x-1]
if not x in list(g.keys()):
return 0
else:
ret = 0
for k in g[x]:
if ret<path(k)+1:
ret = path(k)+1
dp[x-1] = ret
return ret
for i in range(M):
inp = list([int(x) for x in input().split(" ")])
x = inp[0]
y = inp[1]
if not x in list(g.keys()):
g[x] = []
g[x].append(y)
ret = 0
for i in range(1,N+1):
if ret<path(i):
ret = path(i)
print(ret) | import sys
sys.setrecursionlimit(100000000)
inp = list([int(x) for x in input().split(" ")])
N = inp[0]
M = inp[1]
dp = [-1]*N
g = {}
def path(x):
if dp[x-1]!=-1:
return dp[x-1]
if g[x] == []:
return 0
else:
ret = 0
for k in g[x]:
if ret<path(k)+1:
ret = path(k)+1
dp[x-1] = ret
return ret
for i in range(1,N+1):
g[i] = []
for i in range(M):
inp = list([int(x) for x in input().split(" ")])
x = inp[0]
y = inp[1]
g[x].append(y)
ret = 0
for i in range(1,N+1):
if ret<path(i):
ret = path(i)
print(ret) | p03166 |
import sys
sys.setrecursionlimit(10 ** 5 * 2)
N, M = list(map(int, input().split()))
Ps = [[] for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
Ps[x - 1].append(y - 1)
mem = [-1] * N
def rec(n):
if mem[n] > -1:
return mem[n]
elif len(Ps[n]) == 0:
mem[n] = 0
return mem[n]
else:
mem[n] = max([rec(Ps[n][i]) for i in range(len(Ps[n]))]) + 1
return mem[n]
for i in range(N):
rec(i)
print((max(mem))) | import sys
sys.setrecursionlimit(10 ** 5 * 2)
input = sys.stdin.readline
N, M = list(map(int, input().split()))
Ps = [[] for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
Ps[x - 1].append(y - 1)
mem = [-1] * N
def rec(n):
if mem[n] > -1:
return mem[n]
elif len(Ps[n]) == 0:
mem[n] = 0
return mem[n]
else:
mem[n] = max([rec(Ps[n][i]) for i in range(len(Ps[n]))]) + 1
return mem[n]
for i in range(N):
rec(i)
print((max(mem))) | p03166 |
from collections import deque
def main():
n, m = list(map(int, input().split()))
tree_to = [[] for _ in range(n)]
tree_from = [[] for _ in range(n)]
for i in range(m):
x, y = list(map(int, input().split()))
tree_to[x-1].append(y-1)
tree_from[y-1].append(x-1)
ans = [0]*n
already = [False]*n
for i in range(n):
if already[i]:
continue
already[i] = True
not_yet = deque(tree_to[i])
while not_yet:
key = not_yet.pop()
if ans[key] or not tree_to[key]:
already[key] = True
search = deque(tree_from[key])
while search:
already[i]
sub = search.popleft()
ans[sub] = 1
for v in tree_to[sub]:
if ans[sub] < ans[v]+1:
ans[sub] = ans[v]+1
for v in tree_from[sub]:
search.append(v)
continue
for v in tree_to[key]:
not_yet.append(v)
print((max(ans)))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
sys.setrecursionlimit(100007)
def main():
n, m = list(map(int, input().split()))
grid = [[] for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
grid[x-1].append(y-1)
memo = [-1]*n
def dp(n):
if memo[n] != -1:
return memo[n]
res = 0
for v in grid[n]:
res = max(res, dp(v)+1)
memo[n] = res
return res
ans = 0
for i in range(n):
sub = dp(i)
if ans < sub:
ans = sub
print(ans)
if __name__ == "__main__":
main()
| p03166 |
from collections import defaultdict
debug = print
def debug(*va): pass
N, M = map(int, input().split())
dummynode = N
N += 1
nextnodes = [defaultdict(list), defaultdict(list)]
for i in range(M):
x, y = map(int, input().split())
nextnodes[0][x - 1].append(y - 1)
nextnodes[1][y - 1].append(x - 1)
# connect all nodes:
# dummynode -> all nodes
for i in range(N - 1):
nextnodes[0][dummynode].append(i)
nextnodes[1][i].append(dummynode)
def longest_by_topological_sort(i, nexts, prevs):
visited = [-1] * N
visited[i] = 0
max_dist = 0
que = []
for n in nexts[i]:
que.append(n)
while que:
p = que.pop(0)
if visited[p] == -1:
if all(visited[q] != -1 for q in prevs[p]):
dist = max(visited[q] for q in prevs[p])
visited[p] = dist + 1
max_dist = max(max_dist, dist + 1)
for n in nexts[p]:
que.append(n)
return max(visited)
max_dist = longest_by_topological_sort(dummynode, nextnodes[0], nextnodes[1])
max_dist -= 1 # dummy
print(max_dist)
| from collections import defaultdict
debug = print
def debug(*va): pass
def longest_by_topological_sort(N, nexts, prevs):
visited = [-1] * N
max_dist = 0
que = list(range(N))
while len(que):
p = que.pop()
if visited[p] == -1:
if all(visited[q] != -1 for q in prevs[p]):
dist = 0
for q in prevs[p]:
dist = max(dist, visited[q] + 1)
visited[p] = dist
max_dist = max(max_dist, dist)
for n in nexts[p]:
que.append(n)
return max_dist
def test_separate():
import time
N = 10**5
t0 = time.time()
print(longest_by_topological_sort(N, defaultdict(list), defaultdict(list)))
print('elapsed', time.time() - t0)
def test_fanout():
import time
N = 10**5
nn, pp = defaultdict(list), defaultdict(list)
for i in range(1, N):
nn[0].append(i)
pp[i].append(0)
t0 = time.time()
print(longest_by_topological_sort(N, nn, pp))
print('elapsed', time.time() - t0)
def test_middle():
import time
N = 10**5
nn, pp = defaultdict(list), defaultdict(list)
for i in range(1, N):
# fanout
nn[0].append(i)
pp[i].append(0)
# fanin
nn[i].append(1)
pp[1].append(i)
t0 = time.time()
print(longest_by_topological_sort(N, nn, pp))
print('elapsed', time.time() - t0)
if __name__ == '__main__':
N, M = map(int, input().split())
nextnodes = [defaultdict(list), defaultdict(list)]
for i in range(M):
x, y = map(int, input().split())
nextnodes[0][x - 1].append(y - 1)
nextnodes[1][y - 1].append(x - 1)
max_dist = longest_by_topological_sort(N, nextnodes[0], nextnodes[1])
print(max_dist)
| p03166 |
from operator import itemgetter
# スペース区切りの整数入力
N,M = list(map(int, input().split()))
#指定数分の３つの整数を順番に受けてリストに入力
move = []
for i in range(M):
move.append(list(map(int, input().split())))
move.sort(key=itemgetter(0))
dp = [-1] * (N+1)
def findpath(now_x):
if dp[now_x] > -1:
return dp[now_x]
maxpath = 0
for x,y in move:
if now_x == x:
maxpath = max(maxpath,findpath(y) + 1)
if now_x < x:
break
dp[now_x] = maxpath
return maxpath
Ans = 0
for do_x in range(1,N+1):
Ans = max(Ans,findpath(do_x))
print(Ans)
| import sys
sys.setrecursionlimit(10**5)
# スペース区切りの整数入力
N,M = list(map(int, input().split()))
#指定数分の３つの整数を順番に受けてリストに入力
move = {}
for i in range(M):
x,y = list(map(int, input().split()))
move.setdefault(x,[]).append(y)
dp = [-1] * (N+10)
def findpath(now_x):
if dp[now_x] > -1:
return dp[now_x]
maxpath = 0
if now_x in list(move.keys()):
for y in move[now_x]:
maxpath = max(maxpath,findpath(y) + 1)
dp[now_x] = maxpath
return maxpath
Ans = 0
for do_x in range(1,N+1):
Ans = max(Ans,findpath(do_x))
print(Ans)
| p03166 |
from collections import defaultdict
n, m = list(map(int, input().split()))
adj = defaultdict(list)
radj = defaultdict(list)
for i in range(m):
s, e = list(map(int, input().split()))
adj[s].append(e)
radj[e].append(s)
mp = [0]*(n+1)
v = [0]*(n+1)
for i in range(1, 1+n):
if len(adj[i]) == 0:
q = [i]
while q:
e = q.pop()
for j in radj[e]:
mp[j] = max(mp[j], 1+mp[e])
q.append(j)
print((max(mp))) | import sys
from collections import defaultdict
sys.setrecursionlimit(10**9)
n, m = list(map(int, input().split()))
adj = defaultdict(list)
radj = defaultdict(list)
for i in range(m):
s, e = list(map(int, input().split()))
adj[s].append(e)
dp = [-1]*(n+1)
def dfs(e):
if dp[e] != -1:
return dp[e]
temp = 0
for i in adj[e]:
temp = max(temp, 1+dfs(i))
dp[e] = temp
return temp
for i in range(1, n+1):
dfs(i)
print((max(dp))) | p03166 |
import sys
sys.setrecursionlimit(10**7)
N,M=list(map(int,input().split()))
table=[[] for i in range(N)]
Lin=[0]*N
for i in range(M):
w,v=list(map(int,input().split()))
table[w-1].append(v-1)
Lin[v-1]+=1
H=[]
for i in range(N):
if Lin[i]==0:
H.append(i)
dp=[0]*N
def f(x):
if len(table[x])==0:
return
for i in table[x]:
if dp[i]<dp[x]+1:
dp[i]=dp[x]+1
f(i)
return
for i in H:
f(i)
print((max(dp))) | import sys
sys.setrecursionlimit(10**7)
N,M=list(map(int,input().split()))
table=[[] for i in range(N)]
Lin=[0]*N
for i in range(M):
w,v=list(map(int,input().split()))
table[w-1].append(v-1)
Lin[v-1]+=1
H=[]
for i in range(N):
if Lin[i]==0:
H.append(i)
dp=[-1]*N
def f(x):
if dp[x]!=-1:
return dp[x]
if len(table[x])==0:
return 0
t=0
for i in table[x]:
t=max(t,f(i)+1)
dp[x]=t
return t
for i in H:
f(i)
print((max(dp)))
| p03166 |
import sys
from collections import deque
input = sys.stdin.readline
N,M = list(map(int,input().split()))
edge = [list(map(int,input().split())) for _ in range(M)]
graph = [[] for _ in range(N)]
indegree = [0 for _ in range(N)]
for i in range(M):
graph[edge[i][0]-1].append(edge[i][1]-1)
indegree[edge[i][1]-1] += 1
queue = deque()
for i in range(N):
if indegree[i] == 0:
queue.append(i)
dp = [0]*N
while queue:
node = queue.popleft()
for adj in graph[node]:
indegree[adj] -= 1
if indegree[adj] == 0:
queue.append(adj)
dp[adj] = dp[node]+1
print((max(dp))) | import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N)]
deg = [0 for _ in range(N)]
dp = [0 for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
graph[x - 1].append(y - 1)
deg[y - 1] += 1
stack = []
for i in range(N):
if not deg[i]:
stack.append(i)
while stack:
node = stack.pop()
for adj in graph[node]:
deg[adj] -= 1
dp[adj] = max(dp[adj], dp[node] + 1)
if not deg[adj]:
stack.append(adj)
print((max(dp))) | p03166 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = []
for _ in range(M):
a = tuple(map(int, input().split()))
A.append(a)
dp = [-1]*(N+1)
def dfs(n):
global dp
B = list([x for x in A if x[0] == n])
if len(B) == 0:
return 0
ma = 0
for b in B:
x = dp[b[1]]
if x != -1:
ma = max(ma, x + 1)
else:
ma = max(ma, dfs(b[1]) + 1)
dp[n] = ma
return ma
def main():
global dp
for i in range(N):
dp[i] = dfs(i+1)
print((max(dp)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
dp = [-1]*N
def dfs(n):
global dp
if dp[n] > 0:
return dp[n]
ma = 0
for b in G[n]:
ma = max(ma, dfs(b) + 1)
dp[n] = ma
return ma
def main():
global dp
for i in range(N):
dp[i] = dfs(i)
print((max(dp)))
if __name__ == '__main__':
main()
| p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
dp = [-1]*N
def dfs(n):
if dp[n] > 0:
return dp[n]
ma = 0
for b in G[n]:
ma = max(ma, dfs(b) + 1)
return ma
def main():
global dp
for i in range(N):
dp[i] = dfs(i)
print((max(dp)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
dp = [-1]*N
def dfs(n):
global dp
if dp[n] > 0:
return dp[n]
ma = 0
for b in G[n]:
ma = max(ma, dfs(b) + 1)
dp[n] = ma
return ma
def main():
global dp
for i in range(N):
dp[i] = dfs(i)
print((max(dp)))
if __name__ == '__main__':
main()
| p03166 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, M = MAP()
L = [LIST() for i in range(M)]
graph = defaultdict(list)
for a, b in L:
graph[a-1].append(b-1)
ans = 0
dist = [0] * N
for i in range(N):
q = [i]
while q:
a = q.pop()
for node in graph[a]:
if dist[a] + 1 > dist[node]:
dist[node] = dist[a] + 1
# if ans < dist[node]:
# ans = dist[node]
q.append(node)
if ans < max(dist):
ans = max(dist)
print(ans)
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, M = MAP()
gout = [[] for i in range(N)]
deg = [0] * N
for i in range(M):
x, y = MAP()
gout[x-1].append(y-1)
deg[y-1] += 1
# only no_children
topo = [v for v in range(N) if deg[v] == 0]
path_len = [0] * N
ans = 0
q = deque(topo)
# 子を持たない子スタート
while q:
v = q.popleft()
for t in gout[v]:
# 親の子，vのカウントを減らす
deg[t] -= 1
# それでそれ以外の子がいなくなったら，
# トポロジカルソートではスタックに積む
if deg[t] == 0:
q.append(t)
path_len[t] = path_len[v] + 1
ans = path_len[t]
print(ans) | p03166 |
def main():
import sys
sys.setrecursionlimit(10**7)
import collections
dic=collections.defaultdict(list)
N,M=list(map(int,sys.stdin.readline().split()))
for i in range(M):
x,y=list(map(int,sys.stdin.readline().split()))
dic[x].append(y)
dp=[0]*(N+1)
def dfs(frm):
if dp[frm]:
return dp[frm]
mx=0
if frm not in list(dic.keys()):
return 0
for val in dic[frm]:
mx=max(mx,dfs(val)+1)
dp[frm]=mx
return mx
mx=0
for key in list(dic.keys()):
mx=max(mx,dfs(key))
return mx
print((main()))
| def main():
import sys
sys.setrecursionlimit(10**7)
N,M=list(map(int,sys.stdin.readline().split()))
dic=[[] for _ in range(N)]
for i in range(M):
x,y=list(map(int,sys.stdin.readline().split()))
dic[x-1].append(y-1)
dp=[0]*(N)
def dfs(frm):
if dp[frm]:
return dp[frm]
mx=0
if not dic[frm]:
return 0
for val in dic[frm]:
mx=max(mx,dfs(val)+1)
dp[frm]=mx
return mx
mx=0
for key in range(N):
mx=max(mx,dfs(key))
return mx
print((main()))
| p03166 |
def main():
import sys
sys.setrecursionlimit(10**7)
N,M=list(map(int,sys.stdin.readline().split()))
dic=[[] for _ in range(N)]
for i in range(M):
x,y=list(map(int,sys.stdin.readline().split()))
dic[x-1].append(y-1)
dp=[0]*(N)
def dfs(frm):
if dp[frm]:
return dp[frm]
mx=0
if not dic[frm]:
return 0
for val in dic[frm]:
mx=max(mx,dfs(val)+1)
dp[frm]=mx
return mx
mx=0
for key in range(N):
mx=max(mx,dfs(key))
return mx
print((main()))
| def main():
import sys
sys.setrecursionlimit(10**7)
N,M=list(map(int,sys.stdin.readline().split()))
dic=[[] for _ in range(N)]
for i in range(M):
x,y=list(map(int,sys.stdin.readline().split()))
dic[x-1].append(y-1)
dp=[0]*(N)
def dfs(frm):
if dp[frm]:
return dp[frm]
mx=0
if not dic[frm]:
return 0
dp[frm]=max(dfs(val)+1 for val in dic[frm])
return dp[frm]
mx=0
return max(dfs(x) for x in range(N))
print((main()))
| p03166 |
from collections import deque
n,m = list(map(int,input().split()))
path = [set() for _ in range(n)]
dp = [0]*n
for _ in range(m):
x,y = list(map(int,input().split()))
path[x-1].add(y-1)
dp[y-1] = -1
que = deque()
for i in range(n):
if dp[i] == 0:
que.append(i)
ans = 0
while que:
p = que.popleft()
for i in path[p]:
que.append(i)
dp[i] = max(dp[i], dp[p] + 1)
ans = max(ans, dp[i])
print(ans)
| from collections import deque
n,m = list(map(int,input().split()))
path = [set() for _ in range(n)]
to = [0]*n
dp = [0]*n
for _ in range(m):
x,y = list(map(int,input().split()))
path[x-1].add(y-1)
to[y-1] += 1
que = deque()
for i in range(n):
if to[i] == 0:
que.append(i)
ans = 0
while que:
p = que.popleft()
for i in path[p]:
to[i] -= 1
if to[i] == 0:
que.append(i)
dp[i] = max(dp[i], dp[p] + 1)
ans = max(ans, dp[i])
print(ans)
| p03166 |
import sys
import collections
# input処理を高速化する
input = sys.stdin.readline
def chmax(a, b):
""" 最大値を返す関数 """
if a >= b:
return a
else:
return b
def main():
# 入力
N, M = list(map(int, input().split()))
# 隣接関係は隣接リストで管理する
lst_edge = [[] for _ in range(N)]
# 各頂点の入力辺の本数
deg = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
# 最初のindexをゼロにする
lst_edge[x-1].append(y-1)
deg[y-1] += 1
# 入力辺を持たない頂点をqueueに入れる
que = collections.deque()
for v in range(N):
if deg[v] == 0:
que.append(v)
# 各頂点の最初に入力辺を持たなかった点からの距離
dp = [0] * N
while len(que) > 0:
v = que.popleft()
lst_nv = lst_edge[v]
for nv in lst_nv:
# エッジ(v, nv)をグラフから削除する
deg[nv] -= 1
if deg[nv] == 0:
# エッジがなくなったことで、入力辺がなくなったらqueueに入れる
que.append(nv)
# 最初に入力辺を持たなかった点からの距離
dp[nv] = chmax(dp[nv], dp[v] + 1)
print((max(dp)))
main() | import sys
import collections
# input処理を高速化する
input = sys.stdin.readline
def chmax(a, b):
""" 最大値を返す関数 """
if a >= b:
return a
return b
def main():
# 入力
N, M = list(map(int, input().split()))
# 隣接関係は隣接リストで管理する
lst_edge = [[] for _ in range(N)]
# 各頂点の入力辺の本数
deg = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
# 最初のindexをゼロにする
lst_edge[x-1].append(y-1)
deg[y-1] += 1
# 入力辺を持たない頂点をqueueに入れる
que = collections.deque()
for v in range(N):
if deg[v] == 0:
que.append(v)
# 各頂点の最初に入力辺を持たなかった点からの距離
dp = [0] * N
while que:
v = que.popleft()
lst_nv = lst_edge[v]
for nv in lst_nv:
# エッジ(v, nv)をグラフから削除する
deg[nv] -= 1
if deg[nv] == 0:
# エッジがなくなったことで、入力辺がなくなったらqueueに入れる
que.append(nv)
# 最初に入力辺を持たなかった点からの距離
dp[nv] = chmax(dp[nv], dp[v] + 1)
print((max(dp)))
main()
| p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
N,M=list(map(int,input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
to = [[]*(N+1) for _ in range(N+1)]
for i in range(M):
x,y=xy[i]
to[x].append(y)
dp = [0]*(N+1)
def saiki(v):
for u in to[v]:
if dp[u] < dp[v]+1:
dp[u]=dp[v]+1
saiki(u)
count = [True]*(N+1)
count[0] = False
for i in range(M):
count[xy[i][1]] = False
for i in range(1,N+1):
if count[i]:
saiki(i)
print((max(dp)))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
N,M=list(map(int,input().split()))
to = [[]*(N+1) for _ in range(N+1)]
for i in range(M):
x,y=list(map(int,input().split()))
to[x].append(y)
dp = [-1]*(N+1)
def saiki(v):
if dp[v]!=-1: return dp[v]
res = 0
for u in to[v]:
res=max(res,saiki(u)+1)
dp[v]=res
return res
ans=0
for i in range(1,N+1):
ans = max(ans,saiki(i))
print((max(dp)))
| p03166 |
# DAGの最長経路...トポロジカルソートもどきか？
# 普通にDAGに沿ったdpをすればいいのでは?
# 再帰だと実装楽そうだけどどうしよう
# 問題は終了と最初がわからんこと
# いや最初は全部長さ0をセットすればいいだろ
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline # 文字列読み込む時はこっち
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def ints(): return list(map(int, readline().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return tuple(map(list, zip(*ret)))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
N, M = ints()
dag = defaultdict(lambda: [])
indeg = [0] * N
for _ in ra(M):
x, y = mina(*ints())
indeg[y] += 1
dag[x].append(y)
q = deque()
for u, inn in enu(indeg): # 多点DFS初期化
if inn == 0:
q.append(u)
dp = [0] * N
while q: # トポロジカル順序でdpテーブルを埋めていく
u = q.popleft()
# dp[u] = max(dp[u], l)
for nx in dag[u]:
dp[nx] = max(dp[nx], dp[u] + 1)
indeg[nx] -= 1
if indeg[nx] == 0:
q.append(nx)
print(max(dp))
| # DAGの最長経路...トポロジカルソートもどきか？
# 普通にDAGに沿ったdpをすればいいのでは?
# 再帰だと実装楽そうだけどどうしよう
# 問題は終了と最初がわからんこと
# いや最初は全部長さ0をセットすればいいだろ
import sys
sys.setrecursionlimit(1 << 25)
readline = sys.stdin.buffer.readline
read = sys.stdin.readline # 文字列読み込む時はこっち
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def ints(): return list(map(int, readline().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, readline().split())))
return tuple(map(list, zip(*ret)))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
N, M = ints()
dag = defaultdict(lambda: [])
indeg = [0] * N
for _ in ra(M):
x, y = mina(*ints())
indeg[y] += 1
dag[x].append(y)
q = deque()
for u, inn in enu(indeg): # 多点DFS初期化
if inn == 0:
q.append((u, 0))
dp = [0] * N
while q: # トポロジカル順序でdpテーブルを埋めていく
u, l = q.popleft()
# dp[u] = max(dp[u], l)
dp[u] = max(dp[u], l)
for nx in dag[u]:
indeg[nx] -= 1
if indeg[nx] == 0:
q.append((nx, l + 1))
print(max(dp))
| p03166 |
#!/usr/bin/env python3
#EDPC G
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs(s):
if dp[s] != -1:
return dp[s]
elif len(edge[s]) == 0:
return 0
else:
res = 0
for v in edge[s]:
res = max(res,dfs(v)+1)
dp[s] = res
return res
n,m = LI()
dp = [-1]*n
edge = [[] for _ in range(n)]
for _ in range(m):
x,y = LI()
x -= 1
y -= 1
edge[x].append(y)
for i in range(n):
dfs(i)
print((max(dp))) | #!/usr/bin/env python3
#EDPC G
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def dfs(s):
if dp[s] != -1:
return dp[s]
elif len(edge[s]) == 0:
dp[s] = 0
return 0
else:
res = 0
for v in edge[s]:
res = max(res,dfs(v)+1)
dp[s] = res
return res
n,m = LI()
dp = [-1]*n
edge = [[] for _ in range(n)]
for _ in range(m):
x,y = LI()
x -= 1
y -= 1
edge[x].append(y)
for i in range(n):
dfs(i)
print((max(dp))) | p03166 |
from collections import defaultdict
import sys
sys.setrecursionlimit(10**6)
def solve(N, M, edges):
longest = {}
def get_longest(start):
if start in longest:
return longest[start]
next_edges = edges.get(start)
if not next_edges:
ret = 0
else:
ret = max(get_longest(v) for v in edges[start]) + 1
longest[start] = ret
return ret
return max(get_longest(v) for v in edges)
def main():
N, M = list(map(int, input().split()))
edges = defaultdict(set)
for i in range(M):
v1, v2 = list(map(int, input().split()))
edges[v1].add(v2)
print((solve(N, M, edges)))
main()
| #!/usr/bin/env python3
"""
Simple Version
Python TLE https://atcoder.jp/contests/dp/submissions/14906600
PyPy TLE https://atcoder.jp/contests/dp/submissions/14906630
"""
from collections import defaultdict
import sys
sys.setrecursionlimit(10**6)
def solve(N, M, edges):
longest = [-1] * (N + 1)
for i in range(N + 1):
if not edges[i]:
longest[i] = 0
def get_longest(start):
ret = longest[start]
if ret != -1:
return ret
next_edges = edges.get(start)
if not next_edges:
ret = 0
else:
ret = max(get_longest(v) for v in edges[start]) + 1
longest[start] = ret
return ret
return max(get_longest(v) for v in edges)
def main():
N, M = list(map(int, input().split()))
edges = defaultdict(set)
for i in range(M):
v1, v2 = list(map(int, input().split()))
edges[v1].add(v2)
print((solve(N, M, edges)))
main()
| p03166 |
n, m = list(map(int, input().split()))
edges = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
x, y = list(map(int, input().split()))
edges[x][y] = 1
dp = [-1 for _ in range(n+1)]
def longest_path(u):
if dp[u] != -1:
return dp[u]
d = 0
for i in range(1, n+1):
if edges[u][i]:
d = max(d, 1+longest_path(i))
dp[u] = d
return d
for u in range(n+1):
longest_path(u)
print((max(dp)))
| import sys
sys.setrecursionlimit(10**5)
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n+1)]
for _ in range(m):
x, y = list(map(int, input().split()))
edges[x].append(y)
dp = [-1 for _ in range(n+1)]
def longest_path(u):
if dp[u] != -1:
return dp[u]
d = 0
for v in edges[u]:
d = max(d, 1+longest_path(v))
dp[u] = d
return d
for u in range(1, n+1):
longest_path(u)
print((max(dp)))
| p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5+1)
from functools import lru_cache
def main():
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
G[x].append(y)
@lru_cache(maxsize=10**5+1)
def dp(v):
res = 0
for w in G[v]:
res = max(res, dp(w)+1)
return res
ans = 0
for i in range(N):
ans = max(ans, dp(i))
print(ans)
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5+1)
from functools import lru_cache
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
G[x].append(y)
@lru_cache(maxsize=10**5+1)
def dp(v):
res = 0
for w in G[v]:
res = max(res, dp(w)+1)
return res
ans = 0
for i in range(N):
ans = max(ans, dp(i))
print(ans) | p03166 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.