s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s337078976 | p03806 | u557494880 | 1580006105 | Python | Python (3.4.3) | py | Runtime Error | 349 | 56180 | 635 | N,Ma,Mb = map(int,input().split())
dp = [[[10**9 for i in range(400)] for j in range(400)] for k in range(N+1)]
dp[0][0][0] = 0
for i in range(1,N+1):
a,b,c = map(int,input().split())
for j in range(401):
for k in range(401):
if j < a:
d[i][j][k] = d[i-1][j][k]
else:
if k < b:
d[i][j][k] = d[i-1][j][k]
else:
d[i][j][k] = min(d[i-1][j][k],d[i-1][j-a][k-b] + c)
m = max(Ma,Mb)
import math
n = math.floor(400 / m)
ans = 10**9
for i in range(n):
x = Ma*i
y = Mb*i
ans = min(dp[N][x][y])
print(ans) |
s743194382 | p03806 | u404290207 | 1579799012 | Python | PyPy3 (2.4.0) | py | Runtime Error | 167 | 38256 | 713 | w=int(input())
n,k=map(int,input().split())
arr=[]
for _ in range(n):
a,b=map(int,input().split())
arr.append([a,b])
mat=[[[0]*(w+1) for _ in range(k+1)] for _ in range(n+1)]
#W:全体の幅 N：枚数制約 K：重要度 A:スクショの幅 B：スクショの重要度
#全体の幅と枚数を制約として可能な限り重要度の合計を高くする
for num in range(1,n+1):
for kn in range(1,k+1):
for wi in range(1,w+1):
mat[num][kn][wi] = max(mat[num][kn][wi],mat[num-1][kn][wi])
if wi >= arr[num-1][0]:
mat[num][kn][wi] = max(mat[num-1][kn-1][wi-arr[num-1][0]]+arr[num-1][1],mat[num][kn][wi])
print(mat[-1][-1][-1]) |
s265207149 | p03806 | u121921603 | 1579050399 | Python | PyPy3 (2.4.0) | py | Runtime Error | 233 | 115804 | 529 | import sys
input = sys.stdin.readline
n,ma,mb=map(int,input().split())
dp=[[[float("inf")]*500 for _ in range(500)] for i in range(n+1)]
dp[0][0][0]=0
for i in range(n):
a,b,c=map(int,input().split())
for j in range(450):
dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k])
for k in range(450):
dp[i+1][j+a][k+b]=min(dp[i+1][j+a][k+b],dp[i][j][k]+c)
ans=float("inf")
i=1
#print(dp[-1])
while i*ma<450 and i*mb<450:
ans=min(ans,dp[-1][ma*i][mb*i])
i+=1
print(ans if ans!=float("inf") else -1)
|
s359620115 | p03806 | u940139461 | 1578276821 | Python | Python (3.4.3) | py | Runtime Error | 1899 | 3956 | 768 | N, A, B = map(int, input().split())
items = []
A_MAX = 0
B_MAX = 0
for _ in range(N):
a, b, cost = map(int, input().split())
items.append((a, b, cost))
A_MAX += a
B_MAX += b
dp = [[float('infinity')] * (A_MAX + 1) for _ in range(B_MAX + 1)]
dp[0][0] = 0
for a, b, cost in items:
for i in range(B_MAX, -1, -1):
for j in range(A_MAX, -1, -1):
if i - b >= 0 and j - a >= 0:
dp[i][j] = min(dp[i][j], dp[i - b][j - a] + cost)
ans = float('infinity')
for k in range(1, B_MAX + 1):
for l in range(1, A_MAX + 1):
if dp[k][l] == float('infinity'):
continue
if A * dp[k] == dp[l] * B:
ans = min(ans, dp[k][l])
if ans == float('infinity'):
print(-1)
else:
print(ans) |
s884204910 | p03806 | u940139461 | 1578276275 | Python | Python (3.4.3) | py | Runtime Error | 1786 | 4720 | 844 | N, A, B = map(int, input().split())
items = []
A_MAX = 0
B_MAX = 0
for _ in range(N):
a, b, cost = map(int, input().split())
items.append((a, b, cost))
A_MAX += a
B_MAX += b
A_MAX = int(A_MAX)
B_MAX = int(B_MAX)
dp = [[float('infinity')] * (A_MAX + 1) for _ in range(B_MAX + 1)]
dp[0][0] = 0
for a, b, cost in items:
dp[b][a] = cost
for a, b, cost in items:
for i in range(B_MAX + 1):
for j in range(A_MAX + 1):
if i - b >= 0 and j - a >= 0:
dp[i][j] = min(dp[i][j], dp[i - b][j - a] + cost)
ans = float('infinity')
for k in range(1, B_MAX + 1):
for l in range(1, A_MAX + 1):
if dp[k][l] == float('infinity'):
continue
if A * dp[k] == dp[l] * B:
ans = min(ans, dp[k][l])
if ans == float('infinity'):
print(-1)
else:
print(ans) |
s491658916 | p03806 | u940139461 | 1578115371 | Python | PyPy3 (2.4.0) | py | Runtime Error | 402 | 53724 | 844 | N, A, B = map(int, input().split())
items = []
A_MAX = 0
B_MAX = 0
MAX_cost = 0
for _ in range(N):
a, b, cost = map(int, input().split())
items.append((a, b, cost))
A_MAX += a
B_MAX += b
MAX_cost += cost
dp = [[float('infinity')] * (A_MAX + 1) for _ in range(B_MAX + 1)]
dp[0][0] = 0
for a, b, cost in items:
dp[b][a] = cost
for a, b, cost in items:
for i in range(1, B_MAX + 1):
for j in range(1, A_MAX + 1):
if j - a > 0 and i - b > 0:
dp[i][j] = min(dp[i][j], dp[i - b][j - a] + cost)
ans = float('infinity')
for k in range(1, B_MAX + 1):
for l in range(1, A_MAX + 1):
if dp[k][l] == float('infinity'):
continue
if A * dp[k] == dp[l] * B:
ans = min(ans, dp[k][l])
if ans == float('infinity'):
print(-1)
else:
print(ans)
|
s891008687 | p03806 | u940139461 | 1578114705 | Python | Python (3.4.3) | py | Runtime Error | 1604 | 4712 | 826 | N, A, B = map(int, input().split())
items = []
A_MAX = 0
B_MAX = 0
MAX_cost = 0
for _ in range(N):
a, b, cost = map(int, input().split())
items.append((a, b, cost))
A_MAX += a
B_MAX += b
MAX_cost += cost
dp = [[float('infinity')] * (A_MAX + 1) for _ in range(B_MAX + 1)]
# dp[0][0] = 0
for a, b, cost in items:
dp[b][a] = cost
for a, b, cost in items:
for i in range(B_MAX + 1):
for j in range(A_MAX + 1):
if j - a > 0 and i - b > 0:
dp[i][j] = min(dp[i][j], dp[i - b][j - a] + cost)
ans = float('infinity')
for k in range(B_MAX):
for l in range(A_MAX):
if dp[k][l] == float('infinity'):
continue
if A * dp[k] == dp[l] * B:
ans = min(ans, dp[k][l])
if ans == float('infinity'):
print(-1)
else:
print(ans)
|
s337616510 | p03806 | u940139461 | 1578114048 | Python | Python (3.4.3) | py | Runtime Error | 1672 | 4724 | 820 | N, A, B = map(int, input().split())
items = []
A_MAX = 0
B_MAX = 0
MAX_cost = 0
for _ in range(N):
a, b, cost = map(int, input().split())
items.append((a, b, cost))
A_MAX += a
B_MAX += b
MAX_cost += cost
dp = [[float('infinity')] * (A_MAX + 1) for _ in range(B_MAX + 1)]
# dp[0][0] = 0
for a, b, cost in items:
dp[b][a] = cost
for a, b, cost in items:
for i in range(B_MAX):
for j in range(A_MAX):
if j - a >= 0 and i - b >= 0:
dp[i][j] = min(dp[i][j], dp[i - b][j - a] + cost)
ans = float('infinity')
for k in range(B_MAX):
for l in range(A_MAX):
if dp[k][l] == float('infinity'):
continue
if A * dp[k] == dp[l] * B:
ans = min(ans, dp[k][l])
if ans == float('infinity'):
print(-1)
else:
print(ans)
|
s807137464 | p03806 | u254871849 | 1576735127 | Python | Python (3.4.3) | py | Runtime Error | 2124 | 270020 | 1050 | import sys
import numpy as np
from copy import deepcopy
I = np.array(sys.stdin.read().split(), dtype=np.int64)
n, ma, mb = I[:3]
a, b, c = I[3:].reshape(n, 3).T
def main():
sa = np.sum(a)
sb = np.sum(b)
res = [[[[0, 0] for _ in range(sb+1)] for _ in range(sb + 1)] for _ in range(n+1)]
res[0][0][0][0] = 1
for i in range(n):
res[i+1] = deepcopy(res[i])
for j in range(sa+1):
for k in range(sb+1):
if j >= a[i] and k >= b[i]:
prev = res[i][j-a[i]][k-b[i]]
if prev[0]:
res[i+1][j][k][0] = 1
if res[i+1][j][k][1]:
res[i+1][j][k][1] = min(prev[1] + c[i], res[i+1][j][k][1])
else:
res[i+1][j][k][1] = prev[1] + c[i]
for i in range(1, min(sa//ma, sb//mb)+1):
x = res[n][ma * i][mb * i]
if x[0]:
return x[1]
return -1
if __name__ == '__main__':
ans = main()
print(ans) |
s261105014 | p03806 | u150603590 | 1576382259 | Python | PyPy3 (2.4.0) | py | Runtime Error | 167 | 38640 | 928 | import numpy
if __name__ == '__main__':
N,M_a,M_b=list(map(int,input().split()))
A,B,C=[],[],[]
for i in range(N):
a,b,c=list(map(int,input().split()))
A.append(a)
B.append(b)
C.append(c)
dp=[[[1e10 for i in range(max(B)*(N+1))] for j in range(max(A)*(N+1))] for k in range(N+1)]
dp[0][0][0]=0
for i in range(N):
for c_a in range(max(A)*N):
for c_b in range(max(B)*N):
if dp[i][c_a][c_b]==1e10:
continue
dp[i+1][c_a][c_b]=min(dp[i+1][c_a][c_b],dp[i][c_a][c_b])
dp[i+1][c_a+A[i]][c_b+B[i]]=min(dp[i+1][c_a+A[i]][c_b+B[i]],dp[i][c_a][c_b]+C[i])
ans_list=[1e10]
for c_a in A:
for c_b in B:
if c_a*M_b==c_b*M_a:
ans_list.append(dp[N][c_a][c_b])
ans=min(ans_list)
if ans==1e10:
print(-1)
else:
print(ans)
|
s016229815 | p03806 | u470542271 | 1576207607 | Python | Python (3.4.3) | py | Runtime Error | 210 | 5812 | 1068 | n, ma, mb = map(int, input().split())
abc = [list(map(int, input().split())) for _ in range(n)]
m = n * 10 + 1
dp1 = [[float('inf')] * m for i in range(n + 1)]
for i in range(n + 1):
dp1[i][0] = 0
for i in range(n):
for j in range(m):
dp1[i+1][j] = min(dp1[i+1][j], dp1[i][j])
# i個目を買う
jj = j + abc[i][0]
if jj <= 400:
dp1[i+1][jj] = min(dp1[i+1][jj], dp1[i][j] + abc[i][2])
dp2 = [[float('inf')] * m for i in range(n + 1)]
for i in range(n + 1):
dp2[i][0] = 0
for i in range(n):
for j in range(m):
dp2[i+1][j] = min(dp2[i+1][j], dp2[i][j])
# i個目を買う
jj = j + abc[i][1]
if jj <= 400:
dp2[i+1][jj] = min(dp2[i+1][jj], dp2[i][j] + abc[i][2])
from fractions import gcd
ans = float('inf')
for i in range(1, m):
for j in range(1, m):
d1 = dp1[-1][i]
d2 = dp2[-1][j]
g = gcd(i, j)
if i // g == ma and j // g == mb:
ans = min(ans, d1 + d2)
if ans == float('inf'):
print(-1)
else:
print(ans)
|
s431241027 | p03806 | u780475861 | 1575856172 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 427 | n, ma, mb = [int(i) for i in input().split()]
lst = [[int(i) for i in input().split()] for _ in range(n)]
lst.sort(key=lambda x: x[2])
def push(k,v):
if k in dic:
dic[k] = min(dic[k],v)
else:
dic[k] = v
for i in lst:
k, v = i[0] * mb - i[1] * ma, i[2]
l = [[j, dic[j]] for j in dic]
for item in l:
push(item[0] + k, item[1] + v)
push(k, v)
print(dic[0] if 0 in dic else '-1') |
s430705556 | p03806 | u682985065 | 1574133034 | Python | Python (3.4.3) | py | Runtime Error | 430 | 11632 | 644 | n, ma, mb = map(int, input().split())
a, b, c = [0]*n, [0]*n, [0]*n
for i in range(n):
a[i], b[i], c[i] = map(int, input().split())
dp = [[float('inf')] * (sum(a)+1) for _ in range(sum(b)+1)]
dp[0][0] = 0
step = [(0, 0)]
for i in range(n):
ai, bi = a[i], b[i]
s = step.copy()
for si in s:
if dp[si[0]+ai][si[1]+bi] > dp[si[0]][si[1]] + c[i]:
dp[si[0]+ai][si[1]+bi] = dp[si[0]][si[1]] + c[i]
step.append((si[0]+ai, si[1]+bi))
ans = float('inf')
for i in range(1, min(sum(a)//ma, sum(b)//mb)+1):
ans = min(ans, dp[ma*i][mb*i])
if ans == float('inf'): print(-1)
else : print(ans) |
s096758604 | p03806 | u970197315 | 1572321785 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 19 | print(oteagedesita) |
s378434335 | p03806 | u593590006 | 1571536927 | Python | PyPy3 (2.4.0) | py | Runtime Error | 347 | 45676 | 427 | n,ma,mb=map(int,input().split())
dp=[[10**9 for j in range(400)]for i in range(400)]
dp[0][0]=0
for i in range(n):
a,b,c=map(int,input().split())
for x in range(400):
for y in range(400):
if x<a or y<b:
continue
dp[x][y]=min(dp[x][y],dp[x-a][y-b]+c)
mini=10**9
for i in range(1,41):
mini=min(mini,dp[ma*i][mb*i])
if mini>=10**9:
print(-1)
else:
print(mini) |
s929007479 | p03806 | u593590006 | 1571536901 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 8432 | 427 | n,ma,mb=map(int,input().split())
dp=[[10**9 for j in range(400)]for i in range(400)]
dp[0][0]=0
for i in range(n):
a,b,c=map(int,input().split())
for x in range(400):
for y in range(400):
if x<a or y<b:
continue
dp[x][y]=min(dp[x][y],dp[x-a][y-b]+c)
mini=10**9
for i in range(1,41):
mini=min(mini,dp[ma*i][mb*i])
if mini>=10**9:
print(-1)
else:
print(mini) |
s225839042 | p03806 | u760767494 | 1569546500 | Python | Python (3.4.3) | py | Runtime Error | 2137 | 1788616 | 756 | import numpy as np
N, Ma, Mb = map(int, input().split())
l = []
for i in range(N):
l.append(list(map(int, input().split())))
ans = 4001
dp = np.full((N + 1, 100 * N, 100 * N), 4001)
dp[0][0][0] = 0
for n in range(N):
for a in range(10 * N):
for b in range(10 * N):
if dp[n][a][b] == 4001:
continue
dp[n + 1][a][b] = min(dp[n + 1][a][b], dp[n][a][b])
dp[n + 1][a + l[n][0]][b + l[n][1]] = min(dp[n + 1][a + l[n][0]][b + l[n][1]], dp[n][a][b] + l[n][2])
# np.set_printoptions(threshold=np.inf)
# print(dp)
for a in range(1, 10 * N):
for b in range(1, 10 * N):
if a * Mb == b * Ma:
ans = min(ans, dp[n + 1][a][b])
if ans == 4001:
print(-1)
else:
print(ans)
|
s822218268 | p03806 | u760767494 | 1569546466 | Python | PyPy3 (2.4.0) | py | Runtime Error | 167 | 38384 | 756 | import numpy as np
N, Ma, Mb = map(int, input().split())
l = []
for i in range(N):
l.append(list(map(int, input().split())))
ans = 4001
dp = np.full((N + 1, 100 * N, 100 * N), 4001)
dp[0][0][0] = 0
for n in range(N):
for a in range(10 * N):
for b in range(10 * N):
if dp[n][a][b] == 4001:
continue
dp[n + 1][a][b] = min(dp[n + 1][a][b], dp[n][a][b])
dp[n + 1][a + l[n][0]][b + l[n][1]] = min(dp[n + 1][a + l[n][0]][b + l[n][1]], dp[n][a][b] + l[n][2])
# np.set_printoptions(threshold=np.inf)
# print(dp)
for a in range(1, 10 * N):
for b in range(1, 10 * N):
if a * Mb == b * Ma:
ans = min(ans, dp[n + 1][a][b])
if ans == 4001:
print(-1)
else:
print(ans)
|
s608706633 | p03806 | u760767494 | 1569546193 | Python | Python (3.4.3) | py | Runtime Error | 2134 | 1788644 | 756 | import numpy as np
N, Ma, Mb = map(int, input().split())
l = []
for i in range(N):
l.append(list(map(int, input().split())))
ans = 4001
dp = np.full((N + 1, 100 * N, 100 * N), 4001)
dp[0][0][0] = 0
for n in range(N):
for a in range(10 * N):
for b in range(10 * N):
if dp[n][a][b] == 4001:
continue
dp[n + 1][a][b] = min(dp[n + 1][a][b], dp[n][a][b])
dp[n + 1][a + l[n][0]][b + l[n][1]] = min(dp[n + 1][a + l[n][0]][b + l[n][1]], dp[n][a][b] + l[n][2])
# np.set_printoptions(threshold=np.inf)
# print(dp)
for a in range(1, 10 * N):
for b in range(1, 10 * N):
if a * Mb == b * Ma:
ans = min(ans, dp[n + 1][a][b])
if ans == 4001:
print(-1)
else:
print(ans)
|
s223908551 | p03806 | u350248178 | 1567153629 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2125 | 501184 | 616 | n,ma,mb=map(int,input().split())
abc=[]
for i in range(n):
abc.append([int(j) for j in input().split()])
from operator import itemgetter
abc.sort(key=itemgetter(2))
dp=[[10**100 for i in range(401)]for j in range(401)]
dp[0][0]=0
from collections import deque
q=deque([(0,0)])
p=0
for a,b,c in abc:
l=[]
while q:
i,j=q.popleft()
l.append([i,j])
l.append([i+a,j+b])
dp[a+i][b+j]=min(dp[a+i][b+j],dp[i][j]+c)
q=deque(l)
ans=1145141919
i=1
while ma*i<500 and mb*i<500:
ans=min(ans,dp[ma*i][mb*i])
i+=1
if ans==1145141919:
print(-1)
else:
print(ans)
|
s464404301 | p03806 | u585704797 | 1566676007 | Python | PyPy3 (2.4.0) | py | Runtime Error | 181 | 38896 | 782 | n,a,b=[int(x) for x in str(input()).split()]
A=[]
for i in range(n):
A.append([int(x) for x in str(input()).split()])
ans=[]
for i in range(10):
y=[]
for j in range(10):
x=[]
for k in range(n):
x.append(-1)
y.append(x)
ans.append(y)
#print(ans)
#print(A)
def f(ma,mb,cost,index):
if ans[ma][mb][index]==-1:
newa=ma+A[index][0]
newb=mb+A[index][1]
newc=cost+A[index][2]
#print(index,newa,newb,newc)
if newa*b==a*newb:
ans[ma][mb][index]=newc
elif index==n-1:
ans[ma][mb][index]=100000000000000000000
else:
ith=f(newa,newb,newc,index+1)
ans[ma][mb][index]= min(ith,f(ma,mb,cost,index+1))
return ans[ma][mb][index]
if f(0,0,0,0)<100000000000000000000:
print(f(0,0,0,0))
else:
print(-1) |
s971888836 | p03806 | u408760403 | 1565659020 | Python | Python (3.4.3) | py | Runtime Error | 1463 | 60392 | 612 | N,Ma,Mb=map(int,input().split())
abc=[list(map(int,input().split())) for _ in range(N)]
INF=5000
dp=[[[INF]*(10*N+1) for _ in range(10*N+1)] for _ in range(N+1)]
dp[0][0][0]=0
for n in range(N):
a,b,c=abc[n][0],abc[n][1],abc[n][2]
for i in range(10*N+1):
for j in range(10*N+1):
if dp[n][i][j]==INF:
continue
dp[n+1][i][j]=min(dp[n+1][i][j],dp[n][i][j])
dp[n+1][i+a][j+b]=min(dp[n+1][i+a][j+b],dp[n][i][j]+c)
ans=INF
for i in range(1,10*N+1):
if (i*Ma>INF or i*Mb>INF):
break
ans=min(ans,dp[N][i*Ma][i*Mb])
if ans==INF:
print(-1)
else:
print(ans)
|
s957503161 | p03806 | u285443936 | 1565192704 | Python | Python (3.4.3) | py | Runtime Error | 509 | 22004 | 754 | N,Ma,Mb = map(int,input().split())
table = []
sum_a,sum_b,sum_c = 0,0,0
for i in range(N):
a,b,c=map(int,input().split())
sum_a += a
sum_b += b
sum_c += c
table.append((a,b,c))
INF = sum_c+1
ans = INF
dp=[[[INF]*(sum_a+1) for i in range(sum_b+1)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(1,N+1):
a,b,c = table[i-1]
for ca in range(sum_a+1):
for cb in range(sum_b+1):
dp[i][ca][cb] = min(dp[i-1][ca][cb],dp[i][ca][cb])
if ca+a < sum_a and cb+b < sum_b:
dp[i][ca+a][cb+b] = min(dp[i][ca+a][cb+b],dp[i][ca][cb]+c)
for ca in range(sum_a+1):
for cb in range(sum_b+1):
if ca*Ma == cb*Mb and ca*cb != 0:
for i in range(N+1):
ans = min(ans,dp[i][ca][cb])
print(ans if ans != INF else -1) |
s389100867 | p03806 | u191874006 | 1564820858 | Python | PyPy3 (2.4.0) | py | Runtime Error | 295 | 55772 | 1042 | #!/usr/bin/env python3
#ABC54 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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
n,ma,mb = map(int,input().split())
x = [list(map(int,input().split())) for _ in range(n)]
sa = 0
sb = 0
for a,b,c in x:
sa += a
sb += b
dp = [[float('inf')]*(sb+1) for _ in range(sa+1)]
dp[0][0] = 0
for a,b,c in x:
y = [[0]*(sb+1) for _ in range(sb+1)]
for i in range(sa+1):
for j in range(sb+1):
if i+a < sa+1 and j+b < sb+1:
if y[i][j] == 0:
dp[i+a][j+b] = min(dp[i+a][j+b],dp[i][j]+c)
y[i+a][j+b] = 1
ans = float('inf')
for i in range(1,sa+1):
for j in range(1,sb+1):
if i*mb == j*ma:
ans = min(ans,dp[i][j])
if ans == float('inf'):
print(-1)
else:
print(ans)
|
s643634970 | p03806 | u865741247 | 1564625528 | Python | PyPy3 (2.4.0) | py | Runtime Error | 450 | 95836 | 651 |
import math
N,Ma,Mb = map(int,input().split(" "))
drags = [list(map(int,input().split(" "))) for _ in range(N)]
INF = 10 ** 9
lim = N * 10 + 1
dp = [[[ INF for i in range(lim)] for j in range(lim)] for _ in range(N+1)]
dp[0][0][0] = 0
for num in range( N ):
a,b,c = drags[num]
for i in range(a,401): #薬品厨のa の量
for j in range(b,401 ):#薬品厨のb の量
dp[num + 1][i][j] = min(dp[num][i ][j] ,dp[num][i - a][j - b] + c)
ans = INF
for i in range(1,41):
MA = Ma * i
MB = Mb * i
if MA >= lim or MB >= lim:
break
ans = min(ans, dp[-1][MA][MB])
if ans == INF:
ans = -1
print(ans)
|
s548701847 | p03806 | u502389123 | 1564244154 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 953 | N, Ma, Mb = map(int, input().split())
a = [0] * N
b = [0] * N
c = [0] * N
for i in range(N):
a[i], b[i], c[i] = map(int, input().split())
INF = 10 ** 5
nums = 7
dp = [[[INF for _ in range(nums)] for _ in range(nums)] for _ in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for sum_a in range(nums):
for sum_b in range(nums):
if dp[i][sum_a][sum_b] == INF:
continue
dp[i+1][sum_a+a[i]][sum_b+b[i]] = min(dp[i+1][sum_a+a[i]][sum_b+b[i]], dp[i][sum_a][sum_b] + c[i])
dp[i+1][sum_a][sum_b] = min(dp[i+1][sum_a][sum_b], dp[i][sum_a][sum_b])
#dp[i+1][sum_a+a[i]][sum_b+b[i]] = min(dp[i+1][sum_a+a[i]][sum_b+b[i]], dp[i][sum_a][sum_b] + c[i])
#print(i, dp[i][sum_a][sum_b], sum_a, sum_b)
res = INF
for i in range(1, nums):
for j in range(1, nums):
if i * Mb == j * Ma:
res = min(res, dp[N][i][j])
if res == INF:
res = -1
print(res)
|
s357285565 | p03806 | u838644735 | 1562042941 | Python | PyPy3 (2.4.0) | py | Runtime Error | 178 | 38384 | 1675 | N, Ma, Mb = map(int, input().split())
A = [0]*N
B = [0]*N
C = [0]*N
for i in range(N):
A[i], B[i], C[i] = map(int, input().split())
# print(N, Ma, Mb, A, B, C)
A = [Mb * a for a in A]
B = [Ma * b for b in B]
D = []
for i in range(N):
D.append((A[i] - B[i], C[i]))
# print(N, Ma, Mb, A, B, C, D)
Dp = []
Dn = []
Dz = []
for d in D:
if d[0] == 0:
Dz.append(d)
elif d[0] > 0:
Dp.append(d)
else:
Dn.append(d)
Dp.sort(key=lambda x: x[0])
Dn.sort(key=lambda x: x[0])
Dz.sort(key=lambda x: x[1])
min_c = 100*41
if len(Dz) > 0:
min_c = Dz[0][1]
# print(Dp, Dn, Dz, min_c)
Ds = Dn
Dl = Dp
# if len(Dp) < len(Dn):
# Ds, Dl = Dp, Dn
# else:
# Ds, Dl = Dn, Dp
if len(Ds) or len(Dl) == 0:
if min_c == 100*41:
print(-1)
else:
print(min_c)
exit()
def calc(D, l):
s = 0
c = 0
for i in range(len(D)):
if (l >> i) & 1 != 0:
s += D[i][0]
c += D[i][1]
return (s, c)
Ls = len(Ds)
Ll = len(Dl)
Ds_memo = []
Dl_memo = []
for ls in range(1 << (Ls - 1)):
Ds_memo.append(calc(Ds, ls + 1))
for ll in range(1 << (Ll - 1)):
Dl_memo.append(calc(Dl, ll + 1))
Ds_memo.sort(key=lambda x: x[1])
Dl_memo.sort(key=lambda x: x[0])
# print(Ds_memo, Dl_memo)
for ls in Ds_memo:
s = ls[0]
c = ls[1]
# print('ls', ls, s, c)
if c >= min_c:
break
for ll in Dl_memo:
sl = ll[0]
cl = ll[1]
# print('ll', ll, sl, cl)
if s + sl > 0:
break
if c + cl >= min_c:
continue
if s + sl == 0:
min_c = c + cl
if min_c == 100*41:
print(-1)
else:
print(min_c)
|
s125189695 | p03806 | u838644735 | 1562042888 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2117 | 295920 | 1664 | N, Ma, Mb = map(int, input().split())
A = [0]*N
B = [0]*N
C = [0]*N
for i in range(N):
A[i], B[i], C[i] = map(int, input().split())
# print(N, Ma, Mb, A, B, C)
A = [Mb * a for a in A]
B = [Ma * b for b in B]
D = []
for i in range(N):
D.append((A[i] - B[i], C[i]))
# print(N, Ma, Mb, A, B, C, D)
Dp = []
Dn = []
Dz = []
for d in D:
if d[0] == 0:
Dz.append(d)
elif d[0] > 0:
Dp.append(d)
else:
Dn.append(d)
Dp.sort(key=lambda x: x[0])
Dn.sort(key=lambda x: x[0])
Dz.sort(key=lambda x: x[1])
min_c = 100*41
if len(Dz) > 0:
min_c = Dz[0][1]
# print(Dp, Dn, Dz, min_c)
Ds = Dn
Dl = Dp
# if len(Dp) < len(Dn):
# Ds, Dl = Dp, Dn
# else:
# Ds, Dl = Dn, Dp
if len(Ds) == 0:
if min_c == 100*41:
print(-1)
else:
print(min_c)
exit()
def calc(D, l):
s = 0
c = 0
for i in range(len(D)):
if (l >> i) & 1 != 0:
s += D[i][0]
c += D[i][1]
return (s, c)
Ls = len(Ds)
Ll = len(Dl)
Ds_memo = []
Dl_memo = []
for ls in range(1 << (Ls - 1)):
Ds_memo.append(calc(Ds, ls + 1))
for ll in range(1 << (Ll - 1)):
Dl_memo.append(calc(Dl, ll + 1))
Ds_memo.sort(key=lambda x: x[1])
Dl_memo.sort(key=lambda x: x[0])
# print(Ds_memo, Dl_memo)
for ls in Ds_memo:
s = ls[0]
c = ls[1]
# print('ls', ls, s, c)
if c >= min_c:
break
for ll in Dl_memo:
sl = ll[0]
cl = ll[1]
# print('ll', ll, sl, cl)
if s + sl > 0:
break
if c + cl >= min_c:
continue
if s + sl == 0:
min_c = c + cl
if min_c == 100*41:
print(-1)
else:
print(min_c)
|
s592697825 | p03806 | u838644735 | 1562040334 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2106 | 44380 | 1271 | N, Ma, Mb = map(int, input().split())
A = [0]*N
B = [0]*N
C = [0]*N
for i in range(N):
A[i], B[i], C[i] = map(int, input().split())
# print(N, Ma, Mb, A, B, C)
A = [Mb * a for a in A]
B = [Ma * b for b in B]
D = []
for i in range(N):
D.append((A[i] - B[i], C[i]))
# print(N, Ma, Mb, A, B, C, D)
Dp = []
Dn = []
Dz = []
for d in D:
if d[0] == 0:
Dz.append(d)
elif d[0] > 0:
Dp.append(d)
else:
Dn.append(d)
Dp.sort(key=lambda x: x[0])
Dn.sort(key=lambda x: x[0])
Dz.sort(key=lambda x: x[1])
min_c = 100*41
if len(Dz) > 0:
min_c = Dz[0][1]
# print(Dp, Dn, Dz, min_c)
Ds = []
Dl = []
if len(Dp) < len(Dn):
Ds, Dl = Dp, Dn
else:
Ds, Dl = Dn, Dp
def calc(D, l):
s = 0
c = 0
for i in range(len(D)):
if (l >> i) & 1 != 0:
s += D[i][0]
c += D[i][1]
return s, c
Ls = len(Ds)
Ll = len(Dl)
for ls in range(1 << (Ls - 1)):
s, c = calc(Ds, ls + 1)
# print('ls', ls, s, c)
if c >= min_c:
continue
for ll in range(1 << (Ll - 1)):
sl, cl = calc(Dl, ll + 1)
# print('ll', ll, sl, cl)
if c >= min_c:
continue
if s + sl == 0:
min_c = c + cl
if min_c == 100*41:
print(-1)
else:
print(min_c)
|
s688098275 | p03806 | u777923818 | 1561434732 | Python | PyPy3 (2.4.0) | py | Runtime Error | 175 | 38512 | 415 | from itertools import combinations, permutations
def inpl(): return list(map(int, input().split()))
N, M = inpl()
G = [[0]*(N+1) for _ in range(N+1)]
for _ in range(M):
a, b = inpl()
G[a][b] = 1
G[b][a] = 1
ans = 0
for X in permutations(range(2, N+1)):
a = 1
for i in range(N-1):
b = X[i]
if G[a][b] == 0:
break
a = b
else:
ans += 1
print(ans) |
s676392962 | p03806 | u969190727 | 1560296140 | Python | Python (3.4.3) | py | Runtime Error | 1946 | 59468 | 578 | n,ma,mb=map(int,input().split())
inf=10**4
A=[]
append=A.append
for i in range(n):
a,b,c=map(int,input().split())
append([a,b,c])
DP=[[[inf]*(10*n+1) for _ in range(10*n+1)] for _ in range(n+1)]
DP[0][0][0]=0
for i in range(n):
a,b,c=A[i][0],A[i][1],A[i][2]
for j in range(10*(i+1)+1):
for k in range(10*(i+1)+1):
if j>=a and k>=b:
DP[i+1][j][k]=min(DP[i][j-a][k-b]+c,DP[i][j][k])
else:
DP[i+1][j][k]=DP[i][j][k]
ans=inf
for i in range(1,10*n+1):
if i*mb%ma==0:
j=i*mb//ma
ans=min(ans,DP[n][i][j])
print(ans if ans!=inf else -1) |
s285157362 | p03806 | u285443936 | 1559785407 | Python | Python (3.4.3) | py | Runtime Error | 2107 | 3468 | 344 | N, Ma, Mb = map(int, input().split())
abc = [list(map(int, input().split())) for i in range(N)]
tmp = []
for i in range(2**N):
a, b = 0, 0
cost = []
for j in range(N):
if (i>>j) & 1:
cost.append(abc[j][2])
a += abc[j][0]
b += abc[j][1]
if a/Ma == b/Mb and sum(cost) > 0:
tmp.append(sum(cost))
print(min(tmp)) |
s855371918 | p03806 | u785989355 | 1559466261 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 635 | N,M=list(map(int,input().split()))
e_list = []
for i in range(M):
a,b,c = list(map(int,input().split()))
e_list.append([a-1,b-1,-c])
vi=0
min_dis_list = [10**27 for i in range(N)]
min_dis_list[vi] = 0
prev_list = [-1 for i in range(N)]
for i in range(N-1):
for e in e_list:
u,v,d = e
if min_dis_list[v]>min_dis_list[u]+d:
min_dis_list[v]=min_dis_list[u]+d
prev_list[v]=u
neg_loop_flag=False
for e in e_list:
u,v,d = e
if min_dis_list[u] + d < min_dis_list[v]:
neg_loop_flag=True
break
if neg_loop_flag:
print("inf")
else:
print(-min_dis_list[N-1]) |
s922906438 | p03806 | u785989355 | 1559462913 | Python | Python (3.4.3) | py | Runtime Error | 1925 | 60016 | 663 |
N,A,B = list(map(int,input().split()))
item=[]
for i in range(N):
a,b,c = list(map(int,input().split()))
item.append([a,b,c])
D = [[[10**27 for i in range(401)] for j in range(401)] for k in range(N+1)]
D[0][0][0] = 0
for i in range(N):
for j in range(401):
for k in range(401):
if D[i][j][k]<10**26:
D[i+1][j][k]=min(D[i+1][j][k],D[i][j][k])
D[i+1][j+item[i][0]][k+item[i][1]] = min(D[i+1][j+item[i][0]][k+item[i][1]],D[i][j][k]+item[i][2])
i=1
min_cost=10**27
while A*i<=400 and B*i<=400:
min_cost = min(D[A*i][B*i],min_cost)
i+=1
if min_cost==10**27:
print(-1)
else:
print(min_cost) |
s929101467 | p03806 | u785989355 | 1559462826 | Python | Python (3.4.3) | py | Runtime Error | 361 | 56436 | 657 |
N,A,B = list(map(int,input().split()))
item=[]
for i in range(N):
a,b,c = list(map(int,input().split()))
item.append([a,b,c])
D = [[[10**27 for i in range(401)] for j in range(401)] for k in range(N+1)]
D[0][0] = 0
for i in range(N):
for j in range(401):
for k in range(401):
if D[j][k]<10**26:
D[i+1][j][k]=min(D[i+1][j][k],D[i][j][k])
D[i+1][j+item[i][0]][k+item[i][1]] = min(D[i+1][j+item[i][0]][k+item[i][1]],D[i][j][k]+item[i][2])
i=1
min_cost=10**27
while A*i<=400 and B*i<=400:
min_cost = min(D[A*i][B*i],min_cost)
i+=1
if min_cost==10**27:
print(-1)
else:
print(min_cost) |
s484633278 | p03806 | u785989355 | 1559462110 | Python | Python (3.4.3) | py | Runtime Error | 45 | 4340 | 563 | N,A,B = list(map(int,input().split()))
item=[]
for i in range(N):
a,b,c = list(map(int,input().split()))
item.append([a,b,c])
D = [[10**27 for i in range(401)] for j in range(401)]
D[0][0] = 0
for i in range(N):
for j in range(401):
for k in range(401):
if D[j][k]<10**27:
D[j+item[i][0]][k+item[i][1]] = min(D[j+item[i][0]][k+item[i][1]],D[j][k]+item[i][2])
i=1
min_cost=10**27
while A*i<=400 and B*i<=400:
min_cost = min(D[A*i][B*i],min_cost)
i+=1
if min_cost==10**27:
print(-1)
else:
print(min_cost) |
s649683295 | p03806 | u562935282 | 1558167997 | Python | PyPy3 (2.4.0) | py | Runtime Error | 352 | 96476 | 824 | N, Ma, Mb = map(int, input().split())
e = [tuple(map(int, input().split())) for _ in range(N)]
N_max = 40
a_max = 10
b_max = 10
c_max = 100
inf = N_max * c_max + 1
dp = [[[inf for _ in range(N_max * b_max + 1)] for _ in range(N_max * a_max + 1)] for _ in range(N_max + 1)]
dp[0][0][0] = 0
# print(dp[N])
for i, (aa, bb, cc) in enumerate(e, 1):
for a in range(a_max * i + 1):
for b in range(b_max * i + 1):
dp[i][a][b] = min(dp[i][a][b], dp[i - 1][a][b])
dp[i][a + aa][b + bb] = min(dp[i][a + aa][b + bb], dp[i - 1][a][b] + cc)
# print(dp[N])
ans = inf
for a in range(N_max * a_max + 1):
for b in range(N_max * b_max + 1):
# a:b=Ma:Mb
# b*Ma=a*Mb
if b * Ma == a * Mb and a * b > 0:
ans = min(ans, dp[N][a][b])
print(ans if ans < inf else -1)
|
s755052158 | p03806 | u798129018 | 1558140388 | Python | PyPy3 (2.4.0) | py | Runtime Error | 205 | 41072 | 586 | inf = 10**18
N,Ma,Mb = map(int,input().split())
abc = [list(map(int,input().split())) for _ in range(N)]
inf = 10**9
dp = [[inf for i in range(N*10)] for i in range(N*10)]
dp[0][0] = 0
max_a = 0
max_b = 0
for i in range(N):
max_a += abc[i][0]
max_b += abc[i][1]
for ai in range(abc[i][0],max_a+1)[::-1]:
for bi in range(abc[i][1],max_b+1)[::-1]:
dp[ai][bi] = min(dp[ai][bi],dp[ai-abc[i][0]][bi-abc[i][1]]+abc[i][2])
ans = inf
for i in range(1,min(max_a//Ma,max_b//Mb)):
ans = min(ans,dp[i*Ma][i*Mb])
if ans == inf:
print(-1)
else:
print(ans) |
s081804044 | p03806 | u798129018 | 1558140348 | Python | PyPy3 (2.4.0) | py | Runtime Error | 201 | 40944 | 572 | N,Ma,Mb = map(int,input().split())
abc = [list(map(int,input().split())) for _ in range(N)]
inf = 10**9
dp = [[inf for i in range(N*10)] for i in range(N*10)]
dp[0][0] = 0
max_a = 0
max_b = 0
for i in range(N):
max_a += abc[i][0]
max_b += abc[i][1]
for ai in range(abc[i][0],max_a+1)[::-1]:
for bi in range(abc[i][1],max_b+1)[::-1]:
dp[ai][bi] = min(dp[ai][bi],dp[ai-abc[i][0]][bi-abc[i][1]]+abc[i][2])
ans = inf
for i in range(1,min(max_a//Ma,max_b//Mb)):
ans = min(ans,dp[i*Ma][i*Mb])
if ans == inf:
print(-1)
else:
print(ans) |
s687826951 | p03806 | u533885955 | 1555194341 | Python | Python (3.4.3) | py | Runtime Error | 1863 | 59120 | 838 | #D問題
NM=40
ABM=10
MM=400
N,M1,M2=map(int,input().split())
A=[]
B=[]
C=[]
for i in range(N):
a,b,c=map(int,input().split())
A.append(a)
B.append(b)
C.append(c)
cmax=max(C)
CM=N*max(C)+1
dp=[[[CM for broop in range(401)] for aroop in range(401)] for nroop in range(NM)]
dp[0][0][0]=0
for i in range(N-1):
for cb in range(401):
for ca in range(401):
if dp[i][ca][cb]==CM:
continue
dp[i+1][ca][cb]=min(dp[i+1][ca][cb],dp[i][ca][cb])
if ca+A[i]<401 and cb+B[i]<401:
dp[i+1][ca+A[i]][cb+B[i]]=min(dp[i+1][ca+A[i]][cb+B[i]],dp[i][ca][cb]+C[i])
ans=CM
for cb in range(400):
CB=cb+1
for ca in range(400):
CA=ca+1
if ca*M2 == cb*M1:
ans=min(ans,dp[N][CA][CB])
if ans == CM:
print(-1)
else:
print(ans) |
s810403795 | p03806 | u533885955 | 1555193588 | Python | Python (3.4.3) | py | Runtime Error | 1746 | 58348 | 836 | #D問題
NM=40
ABM=10
MM=400
N,M1,M2=map(int,input().split())
A=[]
B=[]
C=[]
for i in range(N):
a,b,c=map(int,input().split())
A.append(a)
B.append(b)
C.append(c)
cmax=max(C)
CM=N*cmax
dp=[[[CM for broop in range(401)] for aroop in range(401)] for nroop in range(NM)]
dp[0][0][0]=0
for i in range(N):
for cb in range(401):
for ca in range(401):
if dp[i][ca][cb]==CM:
continue
dp[i+1][ca][cb]=min(dp[i+1][ca][cb],dp[i][ca][cb])
if ca+A[i]<400 and cb+B[i]<400:
dp[i+1][ca+A[i]][cb+B[i]]=min(dp[i+1][ca+A[i]][cb+B[i]],dp[i][ca][cb]+C[i])
ans=CM
for cb in range(400):
CB=cb+1
for ca in range(400):
CA=ca+1
if ca*M2 == cb*M1:
ans=min(ans,dp[N][CA][CB])
if ans == N*cmax:
print(-1)
else:
print(ans) |
s082073159 | p03806 | u533885955 | 1555193498 | Python | Python (3.4.3) | py | Runtime Error | 1728 | 58224 | 787 | #D問題
NM=40
ABM=10
MM=400
N,M1,M2=map(int,input().split())
A=[]
B=[]
C=[]
for i in range(N):
a,b,c=map(int,input().split())
A.append(a)
B.append(b)
C.append(c)
cmax=max(C)
CM=N*cmax
dp=[[[CM for broop in range(401)] for aroop in range(401)] for nroop in range(NM)]
dp[0][0][0]=0
for i in range(N):
for cb in range(401):
for ca in range(401):
if dp[i][ca][cb]==CM:
continue
dp[i+1][ca][cb]=min(dp[i+1][ca][cb],dp[i][ca][cb])
dp[i+1][ca+A[i]][cb+B[i]]=min(dp[i+1][ca+A[i]][cb+B[i]],dp[i][ca][cb]+C[i])
ans=CM
for cb in range(400):
CB=cb+1
for ca in range(400):
CA=ca+1
if ca*M2 == cb*M1:
ans=min(ans,dp[N][CA][CB])
if ans == N*cmax:
print(-1)
else:
print(ans) |
s110612308 | p03806 | u319818856 | 1554564584 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 4508 | 908 | def mixing_experiment(N: int, Ma: int, Mb: int, drags: list)->int:
INF = float('inf')
max_A = N * max(a for a, _, _ in drags)
max_B = N * max(b for _, b, _ in drags)
dp = [[INF] * (max_A+1) for _ in range(max_B+1)]
dp[0][0] = 0
for (a, b, c) in drags:
for ca in range(max_A-a, -1, -1):
for cb in range(max_B-b, -1, -1):
dp[ca+a][cb+b] = \
min(dp[ca+a][cb+b], dp[ca][cb] + c)
dp[a][b] = min(dp[a][b], c)
ans = min(
dp[ca][cb]
for ca in range(1, max_A+1)
for cb in range(1, max_B+1)
if ca * Mb == cb * Ma)
# print(dp)
return ans if 0 < ans and ans < INF else -1
if __name__ == "__main__":
N = 0
N, Ma, Mb = map(int, input().split())
drags = [tuple(int(s) for s in input().split()) for _ in range(N)]
ans = mixing_experiment(N, Ma, Mb, drags)
print(ans)
|
s334637156 | p03806 | u319818856 | 1554525983 | Python | Python (3.4.3) | py | Runtime Error | 2107 | 57844 | 1103 | def mixing_experiment(N: int, Ma: int, Mb: int, drags: list)->int:
INF = float('inf')
max_A = N * max(a for a, _, _ in drags)
max_B = N * max(b for _, b, _ in drags)
dp = [
[[INF] * (max_A+1) for _ in range(max_B+1)]
for _ in range(N+1)
]
dp[0][0][0] = 0
for n, (a, b, c) in enumerate(drags):
for ca in range(max_A+1):
for cb in range(max_B+1):
dp[n+1][ca][cb] = min(dp[n+1][ca][cb], dp[n][ca][cb])
if max_A < ca + a or max_B < cb + b:
continue
dp[n+1][ca+a][cb+b] = \
min(dp[n+1][ca+a][cb+b], dp[n][ca][cb] + c)
ans = min(
dp[N][ca][cb]
for ca in range(max_A+1)
for cb in range(max_B+1)
if ca > 0 and cb > 0 and ca * Mb == cb * Ma)
# print(dp)
return ans if 0 < ans and ans < INF else -1
if __name__ == "__main__":
N = 0
N, Ma, Mb = map(int, input().split())
drags = [tuple(int(s) for s in input().split()) for _ in range(N)]
ans = mixing_experiment(N, Ma, Mb, drags)
print(ans)
|
s256355988 | p03806 | u319818856 | 1554512843 | Python | Python (3.4.3) | py | Runtime Error | 2107 | 57848 | 1197 | def mixing_experiment(N: int, Ma: int, Mb: int, drags: list) -> int:
INF = float('inf')
max_A = max(a for a, _, _ in drags) * N
max_B = max(b for _, b, _ in drags) * N
dp = [
[[INF]*(max_A + 1) for _ in range(max_B + 1)]
for _ in range(N + 1)
]
dp[0][0][0] = 0
for n in range(N):
a, b, c = drags[n]
for ca in range(max_A + 1):
for cb in range(max_B + 1):
# 薬品 n を加えない
dp[n + 1][ca][cb] = min(dp[n + 1][ca][cb], dp[n][ca][cb])
if max_A < ca + a or max_B < cb + b:
continue
# 薬品 n を加える
dp[n + 1][ca + a][cb + b] = \
min(dp[n + 1][ca + a][cb + b], dp[n][ca][cb] + c)
ans = min(
dp[N][ca][cb]
for ca in range(max_A + 1)
for cb in range(max_B + 1)
if ca * Mb == cb * Ma and ca != 0)
return ans if 0 < ans and ans < INF else -1
if __name__ == "__main__":
N = 0
N, Ma, Mb = map(int, input().split())
drags = [tuple(int(s) for s in input().split()) for _ in range(N)]
ans = mixing_experiment(N, Ma, Mb, drags)
print(ans)
|
s831185253 | p03806 | u123756661 | 1554422623 | Python | Python (3.4.3) | py | Runtime Error | 46 | 3188 | 472 | mod=1777777777
n,ma,mb=map(int,input().split())
d=[[mod for j in range(100)] for i in range(100)]
for i in range(n):
a,b,c=map(int,input().split())
x=a
y=b
for j in range(100-a,0,-1):
for k in range(100-b,0,-1):
if d[j][k]!=mod:
d[j+a][k+b]=min(d[j+a][k+b],d[j][k]+c)
d[x][y]=min(d[x][y],c)
ans=mod
for i in range(100):
if i%ma==0 and mb*i//ma<100:
ans=min(ans,d[i][mb*i//ma])
print([ans,-1][ans==mod])
|
s472129424 | p03806 | u123756661 | 1554422455 | Python | Python (3.4.3) | py | Runtime Error | 66 | 3188 | 474 | mod=1777777777
n,ma,mb=map(int,input().split())
d=[[mod for j in range(100)] for i in range(100)]
for i in range(n):
a,b,c=map(int,input().split())
x=a
y=b
for j in range(100-a,0,-1):
for k in range(100-b-1,0,-1):
if d[j][k]!=mod:
d[j+a][k+b]=min(d[j+a][k+b],d[j][k]+c)
d[x][y]=min(d[x][y],c)
ans=mod
for i in range(100):
if i%ma==0 and mb*i//ma<100:
ans=min(ans,d[i][mb*i//ma])
print([ans,-1][ans==mod])
|
s377596547 | p03806 | u123756661 | 1554356544 | Python | Python (3.4.3) | py | Runtime Error | 225 | 3316 | 442 | mod=1777777777
n,ma,mb=map(int,input().split())
d=[[mod for j in range(100)] for i in range(100)]
for i in range(n):
a,b,c=map(int,input().split())
x=a
y=b
d[x][y]=min(d[x][y],c)
for j in range(100-a):
for k in range(100-b):
if d[j][k]!=mod:
d[j+a][k+b]=min(d[j+a][k+b],d[j][k]+c)
ans=mod
for i in range(100):
if i%a==0:
ans=min(ans,d[i][b*i//a])
print([ans,-1][ans==mod])
|
s697388755 | p03806 | u669696235 | 1552964373 | Python | Python (3.4.3) | py | Runtime Error | 26 | 3444 | 712 | import math
N,Ma,Mb=map(int,input().split())
cost=list()
for i in range(N):
a,b,c=map(int,input().split())
cost.append([a,b,c])
dp=[[float("inf") for _ in range(11)]for _ in range(11)]
dp[0][0]=0
from collections import deque
for i in range(N):
c=cost[i]
for j in range(0,11):
for z in range(0,11):
a=j+c[0]
b=z+c[1]
k=math.gcd(a,b)
a=a//k
b=b//k
if(a>10 or b>10):
continue
dp[a][b]=min(dp[a][b],dp[j][z]+c[2])
ans=10**10
for i in range(1,100):
a=i*Ma
b=i*Mb
if(a>10 or b>10):
break
ans=min(ans,dp[a][b])
if(ans==10**10):
print(-1)
else:
print(ans) |
s745506390 | p03806 | u585482323 | 1551735149 | Python | Python (3.4.3) | py | Runtime Error | 2127 | 361860 | 2205 | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
n,m = LI()
v = LIR(m)
p2 = [1]
for i in range(n):
p2.append(p2[-1]*2)
dp = [[0 for i in range(p2[n])] for j in range(n)]
dp[0][1] = 1
for i in range(1,p2[n]):
for k in range(n):
for a,b in v:
a -= 1
b -= 1
if k==a or k == b:
c = p2[a]
d = p2[b]
if i&c and not i&d:
dp[b][i|d] += dp[k][i]
if (not i&c) and i&d:
dp[a][i|c] += dp[k][i]
ans = 0
for i in range(1,n):
ans += dp[i][-1]
print(ans)
"""
#D
n,p,q = LI()
v = [None for j in range(n)]
sa = 0
sb = 0
for i in range(n):
a,b,c = LI()
v[i] = [a,b,c]
sa += a
sb += b
dp = [[[[float("inf") for i in range(sa+1)] for j in range(sb+1)] for k in range(n+1)] for l in range(n+1)]
dp[0][0][0][0] = 0
for i in range(n):
for j in range(n):
for a in range(sa):
for b in range(sb):
ai,bi,ci = v[i]
if a + ai <= sa and b+bi <= sb:
dp[i+1][j+1][a+ai][b+bi] = min(dp[i+1][j+1][a+ai][b+bi],dp[i][j][a][b]+ci,dp[i][j+1][a+ai][b+bi])
li = [[p,q]]
while li[-1][0] <= sa and li[-1][1] <= sb:
li.append([li[-1][0]+p,li[-1][1]+q])
li.pop(-1)
ans = float("inf")
for i in range(1,n+1):
for a,b in li:
ans = min(ans,dp[n][i][a][b])
if ans == float("inf"):
print(-1)
else:
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
s634438138 | p03806 | u695811449 | 1551689585 | Python | Python (3.4.3) | py | Runtime Error | 1922 | 4872 | 512 | N,MA,MB=map(int,input().split())
S=[list(map(int,input().split())) for i in range(N)]
DPLIST=[[10**6 for i in range(401)] for j in range(401)]
DPLIST[0][0]=0
for a,b,c in S:
for i in range(400,a-1,-1):
for j in range(400,b-1,-1):
if DPLIST[i][j]>DPLIST[i-a][j-b]+c:
DPLIST[i][j]=DPLIST[i-a][j-b]+c
ANS=10**6
for k in range(1,400//max(i,j)):
if DPLIST[MA*k][MB*k]<ANS:
ANS=DPLIST[MA*k][MB*k]
if ANS==10**6:
print(-1)
else:
print(ANS) |
s273063090 | p03806 | u690536347 | 1548990163 | Python | PyPy3 (2.4.0) | py | Runtime Error | 819 | 133596 | 550 | n,Ma,Mb=map(int,input().split())
inf=float("inf")
dp=[[[inf]*401 for _ in range(401)] for _ in range(n+1)]
dp[0][0][0]=0
l=[tuple(map(int,input().split())) for _ in range(n)]
for i in range(1,n+1):
for j in range(401):
for k in range(401):
a,b,c=l[i-1]
dp[i][j][k]=min(dp[i][j][k],dp[i-1][j][k])
if j-a>=0 and k-b>=0:
dp[i][j][k]=min(dp[i][j][k],dp[i-1][j-a][k-b]+c)
ans=inf
for i in range(1,1+max(400//Ma,400//Mb)):
ans=min(ans,dp[n][Ma*i][Mb*i])
print(ans if ans!=inf else -1) |
s238785644 | p03806 | u588341295 | 1548303094 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3064 | 776 | # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, Ma, Mb = map(int, input().split())
l = [[0] * 3 for i in range(N)]
for i in range(N):
l[i][0], l[i][1], l[i][2] = map(int, input().split())
memo = [[[INF] * 11 for i in range(11)] for i in range(N+1)]
def dfs(cur, a, b, c):
if memo[cur][a][b] != INF:
return memo[cur][a][b]
if cur == N:
return INF
mn = INF
if b != 0 and a / b == Ma / Mb:
mn = min(c, mn)
mn = min(dfs(cur+1, a+l[cur][0], b+l[cur][1], c+l[cur][2]), mn)
mn = min(dfs(cur+1, a, b, c), mn)
memo[cur][a][b] = mn
return mn
ans = dfs(0, 0, 0, 0)
if ans == INF:
print(-1)
else:
print(ans)
|
s680013881 | p03806 | u375616706 | 1547953129 | Python | Python (3.4.3) | py | Runtime Error | 1670 | 58312 | 735 | N, Ma, Mb = (list)(map(int, input().split()))
l = []
inf = 10**6
dp = [[[inf]*402 for _ in range(402)] for _ in range(40)]
for _ in range(N):
l.append((list)(map(int, input().split())))
dp[0][0][0] = 0
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][ca][cb] != inf:
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
t_a = l[i][0]
t_b = l[i][1]
dp[i+1][ca+t_a][cb+t_b] =\
min(dp[i+1][ca+t_a][cb+t_b], dp[i][ca][cb]+l[i][2])
ans = inf
for i in range(1, 402):
for j in range(1, 402):
if i*Mb == j*Ma:
ans = min(ans, dp[N][i][j])
if ans == inf:
ans = -1
print(ans)
|
s242669503 | p03806 | u375616706 | 1547953063 | Python | Python (3.4.3) | py | Runtime Error | 1536 | 59752 | 735 | N, Ma, Mb = (list)(map(int, input().split()))
l = []
inf = 10**6
dp = [[[inf]*402 for _ in range(402)] for _ in range(40)]
for _ in range(N):
l.append((list)(map(int, input().split())))
dp[0][0][0] = 0
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][ca][cb] != inf:
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
t_a = l[i][0]
t_b = l[i][1]
dp[i+1][ca+t_a][cb+t_b] =\
min(dp[i+1][ca+t_a][cb+t_b], dp[i][ca][cb]+l[i][2])
ans = inf
for i in range(1, 401):
for j in range(1, 401):
if i*Mb == j*Ma:
ans = min(ans, dp[N][i][j])
if ans == inf:
ans = -1
print(ans)
|
s556414100 | p03806 | u375616706 | 1547952483 | Python | Python (3.4.3) | py | Runtime Error | 1443 | 58220 | 757 | N, Ma, Mb = (list)(map(int, input().split()))
N_max = 40
abmax = 10
l = []
inf = 10**6
dp = [[[inf]*401 for _ in range(401)] for _ in range(40)]
for _ in range(N):
l.append((list)(map(int, input().split())))
dp[0][0][0] = 0
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][ca][cb] != inf:
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
t_a = l[i][0]
t_b = l[i][1]
dp[i+1][ca+t_a][cb+t_b] =\
min(dp[i+1][ca+t_a][cb+t_b], dp[i][ca][cb]+l[i][2])
ans = inf
for i in range(1, 401):
for j in range(1, 401):
if i*Mb == j*Ma:
ans = min(ans, dp[N][i][j])
if ans == inf:
ans = -1
print(ans)
|
s824751378 | p03806 | u375616706 | 1547952031 | Python | Python (3.4.3) | py | Runtime Error | 1453 | 59244 | 751 | N, Ma, Mb = (list)(map(int, input().split()))
N_max = 40
abmax = 10
l = []
inf = 10**6
dp = [[[inf]*401 for _ in range(401)] for _ in range(40)]
for _ in range(N):
l.append((list)(map(int, input().split())))
dp[0][0][0] = 0
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][ca][cb] != inf:
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
t_a = l[i][0]
t_b = l[i][1]
dp[i+1][ca+t_a][cb+t_b] =\
min(dp[i+1][ca+t_a][cb+t_b], dp[i][ca][cb]+l[i][2])
ans = inf
for i in range(401):
for j in range(401):
if i*Mb == j*Ma:
ans = min(ans, dp[N][i][j])
if ans == inf:
ans = -1
print(ans)
|
s714292392 | p03806 | u427344224 | 1547700678 | Python | PyPy3 (2.4.0) | py | Runtime Error | 434 | 106716 | 885 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 40)] for _ in range(b_sum + 40)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum):
for b in range(b_sum):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1)
|
s584063149 | p03806 | u427344224 | 1547700656 | Python | PyPy3 (2.4.0) | py | Runtime Error | 409 | 90460 | 885 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 20)] for _ in range(b_sum + 20)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum):
for b in range(b_sum):
if dp[i + 1][a][b] > dp[i][a][b]:
dp[i + 1][a][b] = dp[i][a][b]
if dp[i + 1][a + items[i][0]][b + items[i][1]] > dp[i][a][b] + items[i][2]:
dp[i + 1][a + items[i][0]][b + items[i][1]] = dp[i][a][b] + items[i][2]
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1)
|
s854323767 | p03806 | u427344224 | 1547699993 | Python | Python (3.4.3) | py | Runtime Error | 496 | 56308 | 761 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
inf = float("inf")
dp = [[[inf for _ in range(401)] for _ in range(401)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(401):
for b in range(401):
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + items[i][0]][b + items[i][1]] = min(dp[i + 1][a + items[i][0]][b + items[i][1]],
dp[i][a][b] + items[i][2])
ans = inf
for a in range(1, 401):
for b in range(1, 401):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1) |
s927370938 | p03806 | u427344224 | 1547699686 | Python | Python (3.4.3) | py | Runtime Error | 2106 | 30452 | 881 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 40)] for _ in range(b_sum + 40)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum + 1):
for b in range(b_sum + 1):
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + items[i][0]][b + items[i][1]] = min(dp[i + 1][a + items[i][0]][b + items[i][1]],
dp[i][a][b] + items[i][2])
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1) |
s804091828 | p03806 | u427344224 | 1547699645 | Python | Python (3.4.3) | py | Runtime Error | 2105 | 27508 | 881 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 20)] for _ in range(b_sum + 20)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum + 1):
for b in range(b_sum + 1):
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + items[i][0]][b + items[i][1]] = min(dp[i + 1][a + items[i][0]][b + items[i][1]],
dp[i][a][b] + items[i][2])
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1) |
s867879482 | p03806 | u427344224 | 1547699442 | Python | Python (3.4.3) | py | Runtime Error | 552 | 23668 | 881 | N, Ma, Mb = map(int, input().split())
items = []
for i in range(N):
a, b, c = map(int, input().split())
items.append((a, b, c))
a_sum = sum([item[0] for item in items])
b_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [[[inf for _ in range(a_sum + 11)] for _ in range(b_sum + 11)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(a_sum + 1):
for b in range(b_sum + 1):
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + items[i][0]][b + items[i][1]] = min(dp[i + 1][a + items[i][0]][b + items[i][1]],
dp[i][a][b] + items[i][2])
ans = inf
for a in range(1, a_sum + 1):
for b in range(1, b_sum + 1):
if a * Mb == b * Ma:
ans = min(ans, dp[N][a][b])
if ans != inf:
print(ans)
else:
print(-1) |
s340029879 | p03806 | u738835924 | 1545691223 | Python | Python (3.4.3) | py | Runtime Error | 2120 | 213364 | 526 | N, Ma, Mb = map(int, input().split())
dp = [[[float("inf") for _ in range(401)] for _ in range(401)] for _ in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
a,b,c = map(int, input().split())
for j in range(401):
for k in range(401):
if j-a < 0 or k-b < 0:
dp[i+1][j][k] = dp[i][j][k]
else:
dp[i+1][j][k] = min(dp[i][j][k], dp[i][j-a][k-b] + c)
ans = float("inf")
a = Ma
b = Mb
while(a < 401 or b < 401):
ans = min(ans, dp[N][a][b])
a += Ma
b += Mb
print(ans) |
s592674073 | p03806 | u054106284 | 1543987256 | Python | Python (3.4.3) | py | Runtime Error | 2107 | 60920 | 736 | N, Ma, Mb= (int(i) for i in input().split())
L = []
for i in range(N):
a, b, c = (int(i) for i in input().split())
L.append((a-1, b-1, c))
dp= [[[float("inf")] * (10 * N + 11) for a in range(10 * N + 11) ] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N + 1):
a, b, c = L[i]
for ca in range(10 * N + 1):
for cb in range(10 * N + 1):
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
dp[i+1][ca + a][cb + b] = min(dp[i+1][ca + a][cb + b], dp[i][ca][cb] + c)
reslis = []
ra, rb = (Ma, Mb)
while ra <= 10 * N and rb <= 10 * N:
reslis.append(dp[N][ra][rb])
ra += Ma
rb += Mb
reslis.sort()
res = reslis[0]
if res == float("inf"):
print(-1)
else:
print(res)
|
s021693596 | p03806 | u054106284 | 1543986538 | Python | Python (3.4.3) | py | Runtime Error | 1694 | 213368 | 741 | N, Ma, Mb= (int(i) for i in input().split())
L = []
for i in range(N):
a, b, c = (int(i) for i in input().split())
L.append((a-1, b-1, c))
dp= [[[float("inf") for b in range(10 * N + 1)] for a in range(10 * N + 1) ] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
a, b, c = L[i]
for ca in range(10 * N + 1):
for cb in range(10 * N + 1):
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
dp[i+1][ca + a][cb + b] = min(dp[i+1][ca + a][cb + b], dp[i][ca][cb] + c)
reslis = []
ra, rb = (Ma, Mb)
while ra <= 10 * N and rb <= 10 * N:
reslis.append(dp[N][ra][rb])
ra += Ma
rb += Mb
reslis.sort()
res = reslis[0]
if res == float("inf"):
print(-1)
else:
print(res) |
s866166818 | p03806 | u426108351 | 1540405844 | Python | PyPy3 (2.4.0) | py | Runtime Error | 183 | 39408 | 644 | import itertools
import numpy
N, Ma, Mb = map(int, input().split())
r = Ma/Mb
costlist = []
data = [list(map(int, input().split())) for i in range(N)]
for i in range(1, max(N+1, 11)):
combination = numpy.array(list(itertools.combinations(data, i)))
for k in range(len(combination)):
a_tot = 0
b_tot = 0
c_tot = 0
for j in range(len(combination[k])):
a_tot += combination[k][j][0]
b_tot += combination[k][j][1]
c_tot += combination[k][j][2]
if a_tot/b_tot == r:
costlist.append(c_tot)
if costlist == []:
print(-1)
else:
print(min(costlist))
|
s607719982 | p03806 | u785989355 | 1539968897 | Python | Python (2.7.6) | py | Runtime Error | 11 | 2696 | 621 | N,ma,mb = map(int,raw_input().split())
a=[]
b=[]
c=[]
for i in range(N):
at,bt,ct=map(int,raw_input().split())
a.append(at)
b.append(bt)
c.append(ct)
dp = [[[10**10 for i in range(400+1)] for j in range(400+1)] for k in range(N+1)]
dp[0][0][0]=0
for i in range(N):
for j in range(401):
for k in range(401):
if(dp[i][j][k]<10**10):
dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k])
dp[i+1][j+a[i]][k+b[i]]=min(dp[i+1][j+a[i]][k+b[i]],dp[i][j][k]+c[i])
int ans=10**10
for i in range(1,401):
for j in range(1,401):
if i*mb==j*ma:
ans=min(ans,dp[N][i][j])
if ans>=10**10:
print -1
else:
print ans |
s676295028 | p03806 | u942033906 | 1537823426 | Python | Python (3.4.3) | py | Runtime Error | 1739 | 3188 | 1327 | N,Ma,Mb = map(int,input().split())
first_half = []
last_half = []
for i in range(N):
a,b,c = map(int,input().split())
if i < N // 2:
first_half.append((a,b,c))
else:
last_half.append((a,b,c))
first_half_combination = {}
last_half_combination = {}
def make_all_combination(i,a,b,c,d_list,flag):
if i == len(d_list):
if c == 0:
return
w = Ma * b - Mb * a
if flag:
if w not in first_half_combination or c < first_half_combination[w]:
first_half_combination[w] = c
else:
if -w not in last_half_combination or c < last_half_combination[-w]:
last_half_combination[-w] = c
return
make_all_combination(i+1,a,b,c,d_list,flag)
make_all_combination(i+1,a+d_list[i][0],b+d_list[i][1],c+d_list[i][2],d_list,flag)
make_all_combination(0,0,0,0,first_half,True)
make_all_combination(0,0,0,0,last_half,False)
INF = 10**8
f_0 = first_half_combination[0] if 0 in last_half_combination else INF
l_0 = first_half_combination[0] if 0 in last_half_combination else INF
ans = min(f_0,l_0) if min(f_0,l_0) < INF else -1
for w in first_half_combination.keys():
if w == 0:
continue
if w in last_half_combination:
cost = first_half_combination[w] + last_half_combination[w]
if w == 0:
cost = min(first_half_combination[w], last_half_combination[w])
if ans == -1 or cost < ans:
ans = cost
print(ans) |
s024333021 | p03806 | u942033906 | 1537822848 | Python | Python (3.4.3) | py | Runtime Error | 80 | 3964 | 1399 | N,Ma,Mb = map(int,input().split())
first_half = []
last_half = []
for i in range(N):
a,b,c = map(int,input().split())
if i < N // 2:
first_half.append((a,b,c))
else:
last_half.append((a,b,c))
first_half_combination = {}
last_half_combination = {}
def make_all_combination(i,a,b,c,d_list,flag):
if i == len(d_list) and c > 0:
w = Ma * b - Mb * a
if flag:
if w not in first_half_combination or c < first_half_combination[w]:
first_half_combination[w] = c
else:
if -w not in last_half_combination or c < last_half_combination[-w]:
last_half_combination[-w] = c
return
make_all_combination(i+1,a,b,c,d_list,flag)
make_all_combination(i+1,a+d_list[i][0],b+d_list[i][1],c+d_list[i][2],d_list,flag)
def search(w, lst):
left,right = 0, len(lst)
while left + 1 != right:
p = (left + right) // 2
if lst[p][0] < w:
left = p
else:
right = p
return left
make_all_combination(0,0,0,0,first_half,True)
make_all_combination(0,0,0,0,last_half,False)
print(first_half_combination)
print(last_half_combination)
ans = -1
for w in first_half_combination.keys():
if w in last_half_combination:
cost = first_half_combination[w] + last_half_combination[w]
if w == 0:
cost = min(first_half_combination[w], last_half_combination[w])
if ans == -1 or cost < ans:
ans = cost
elif w == 0:
cost = first_half_combination[w]
if cost < ans:
ans = cost
print(ans) |
s951641046 | p03806 | u354638986 | 1530118255 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 1054 | #include <iostream>
#include <algorithm>
using namespace std;
const int max_n = 40, max_ab = 10, INF = 100001;
int a[max_n], b[max_n], c[max_n];
int dp[max_n + 1][max_n*max_ab + 1][max_n*max_ab + 1];
int main()
{
int n, ma, mb;
cin >> n >> ma >> mb;
for (int i = 0;i < n;i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 0;i <= n;i++) {
for (int j = 0;j <= n * max_ab;j++) {
for (int k = 0;k <= n * max_ab;k++) {
dp[i][j][k] = INF;
}
}
}
dp[0][0][0] = 0;
for (int i = 1;i <= n;i++) {
for (int j = 1;j <= n * max_ab;j++) {
for (int k = 1;k <= n * max_ab;k++) {
if (a[i - 1] <= j && b[i - 1] <= k) {
dp[i][j][k] = min(dp[i - 1][j][k], dp[i - 1][j - a[i - 1]][k - b[i - 1]] + c[i - 1]);
}
else dp[i][j][k] = dp[i - 1][j][k];
}
}
}
int min_cost = INF;
for (int i = 1;i <= n * max_ab;i++) {
for (int j = 1;j <= n * max_ab;j++) {
if (i * mb == j * ma) min_cost = min(min_cost, dp[n][i][j]);
}
}
if (min_cost == INF) cout << -1 << endl;
else cout << min_cost << endl;
return 0;
}
|
s947242557 | p03806 | u522398430 | 1530005378 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 14180 | 663 | import numpy as np
from functools import reduce
N, Ma, Mb = map(int, input().split())
X = np.array([list(map(int, input().split())) for _ in range(N)])
z = []
def update_z(_y, index2):
tmp = reduce(lambda a,b:a+b, [x for k,x in enumerate(X) if k in index2])
if tmp[0]*Mb == tmp[1]*Ma:
z.append(min(_y, tmp[2]))
def rec(y=4001, i=0, index=None):
if i<N:
if index:
for j in range(i,N):
update_z(y, index+[j])
rec(y, j+1, index + [j])
else:
for j in range(i,N):
update_z(y, [j])
rec(y, j+1, [j])
rec()
print(-1 if min(z)>4000 else min(z)) |
s558446901 | p03806 | u732963817 | 1529999345 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 578 | from itertools import combinations
N, Ma, Mb = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in range(N)]
c_max = abc[np.array([_i[2] for _i in abc], dtype='int8').argmax()]
min_cost = -1
for _i in range(1, N+1):
all_pattern = list(combinations(range(N), _i))
for _j in all_pattern:
_a = sum([abc[_k][0] for _k in _j])
_b = sum([abc[_k][1] for _k in _j])
_c = sum([abc[_k][2] for _k in _j])
if _b * Ma == _a * Mb:
if min_cost == -1 or min_cost > _c:
min_cost = _c
print(min_cost) |
s055008844 | p03806 | u732963817 | 1529999197 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 578 | N, Ma, Mb = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in range(N)]
from itertools import combinations
c_max = abc[np.array([_i[2] for _i in abc], dtype='int8').argmax()]
min_cost = -1
for _i in range(1, N+1):
all_pattern = list(combinations(range(N), _i))
for _j in all_pattern:
_a = sum([abc[_k][0] for _k in _j])
_b = sum([abc[_k][1] for _k in _j])
_c = sum([abc[_k][2] for _k in _j])
if _b * Ma == _a * Mb:
if min_cost == -1 or min_cost > _c:
min_cost = _c
print(min_cost) |
s824627757 | p03806 | u467736898 | 1529543202 | Python | PyPy3 (2.4.0) | py | Runtime Error | 171 | 38384 | 578 | N, Ma, Mb = map(int, input().split())
L = [[float("inf")]*410 for i in range(410)]
P = [[0, 0]]
L[0][0] = 0
for i in range(N):
a, b, c = map(int, input().split())
OldP = P.copy()
Lsub = [L[p[0]][p[1]] for p in OldP]
for xp, p in enumerate(OldP):
if L[p[0]+a][p[1]+b] == float("inf"):
P.append([p[0]+a, p[1]+b])
L[p[0]+a][p[1]+b] = min(L[p[0]+a][p[1]+b], Lsub[xp]+c)
g = [Ma, Mb]
ans = float("inf")
while g[0]<410 and g[1]<410:
ans = min(ans, L[g[0]][g[1]])
g[0] += Ma
g[1] += Mb
print(ans if ans != float("inf") else -1)
|
s892366979 | p03806 | u682985065 | 1527727696 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 692 | n, ma, mb = map(int, f.readline().split())
a, b, c = [], [], []
for _ in range(n):
at, bt, ct = map(int, f.readline().split())
a.append(at)
b.append(bt)
c.append(ct)
dp = [[float('inf') for _ in range(n*mb + 1)] for _ in range(n*ma + 1)]
dp[0][0] = 0
used = [[0, 0]]
for i in range(n):
add_used = []
for at, bt in used:
if at+a[i] <= n and bt+b[i] <= n:
if dp[at+a[i]][bt+b[i]] == float('inf'):
add_used.append([at+a[i], bt+b[i]])
dp[at+a[i]][bt+b[i]] = min(dp[at][bt]+c[i], dp[at+a[i]][bt+b[i]])
used += add_used
if dp[-1][-1] == float('inf'):
print(-1)
else :
print(dp[-1][-1]) |
s324863605 | p03806 | u777923818 | 1526678791 | Python | Python (3.4.3) | py | Runtime Error | 44 | 5748 | 584 | # -*- coding: utf-8 -*-
def inpl(): return map(int, input().split())
N, Ma, Mb = inpl()
INF = 4001
DP = [[INF]*(411) for _ in range(411)]
DP[0][0] = 0
for i in range(N):
DP2 = [[INF]*(411) for _ in range(411)]
a, b, c = inpl()
for i in range(10*(i+1) + 1):
for j in range(10*(i+1) + 1):
DP2[i][j] = min(DP[i][j], DP2[i][j])
DP2[i+a][j+b] = min(DP[i+a][j+b], DP[i][j] + c)
DP = DP2
x = 1
ans = INF
while Ma*x <= 400 and Mb*x <= 400:
ans = min(ans, DP[Ma*x][Mb*x])
x += 1
if ans < INF:
print(ans)
else:
print(-1) |
s189208873 | p03806 | u653005308 | 1524707735 | Python | Python (3.4.3) | py | Runtime Error | 570 | 84852 | 849 | n,ma,mb=map(int,input().split())
lista=[]
listb=[]
listc=[]
for i in range(n):
a,b,c=map(int,input().split())
lista.append(a)
listb.append(b)
listc.append(c)
x=sum(lista)
y=sum(listb)
z=0
w=0
dp=[[[float('inf') for i in range(n+1)]for i\
in range(y+1)]for i in range(x+1)]
for i in range(n+1):
dp[0][0][i]=0
for i in range(1,n+1):
z+=lista[i-1]
y+=listb[i-1]
for a in range(z+1):
for b in range(w+1):
if a-lista[i-1]>=0 and b-listb[i-1]>=0:
dp[a][b][i]=min(dp[a][b][i-1],dp[a-lista[i-1]][b-listb[i-1]][i-1]+listc[i-1])
else:
dp[a][b][i]=dp[a][b][i-1]
cost=float('inf')
for a in range(1,x+1):
if float.is_integer(a*mb/ma) and a*mb/ma<=y+1:
cost=min(cost,dp[a][int(a*mb/ma)][n])
if cost==float('inf'):
print(-1)
else:
print(cost)
|
s980395593 | p03806 | u653005308 | 1524707668 | Python | Python (3.4.3) | py | Runtime Error | 584 | 84852 | 896 | n,ma,mb=map(int,input().split())
lista=[]
listb=[]
listc=[]
for i in range(n):
a,b,c=map(int,input().split())
lista.append(a)
listb.append(b)
listc.append(c)
x=sum(lista)
y=sum(listb)
z=0
w=0
dp=[[[float('inf') for i in range(n+1)]for i\
in range(y+1)]for i in range(x+1)]
for i in range(n+1):
dp[0][0][i]=0
for i in range(1,n+1):
if i==n:
continue
else:
z+=lista[i-1]
y+=listb[i-1]
for a in range(z+1):
for b in range(w+1):
if a-lista[i-1]>=0 and b-listb[i-1]>=0:
dp[a][b][i]=min(dp[a][b][i-1],dp[a-lista[i-1]][b-listb[i-1]][i-1]+listc[i-1])
else:
dp[a][b][i]=dp[a][b][i-1]
cost=float('inf')
for a in range(1,x+1):
if float.is_integer(a*mb/ma) and a*mb/ma<=y+1:
cost=min(cost,dp[a][int(a*mb/ma)][n])
if cost==float('inf'):
print(-1)
else:
print(cost) |
s469564552 | p03806 | u653005308 | 1524700397 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 697 | n,ma,mb=map(int,input().split())
lista=[]
listb=[]
listc=[]
for i in range(n):
a,b,c=map(int,input().split())
lista.append(a)
listb.append(b)
listc.append(c)
dp=[[[float('inf') for i in range(n+1)]for i\
in range(sum(listb)+1)]for i in range(sum(lista)+1)]
dp[0][0][0]=0
for i in range(1,n+1):
for a in range(lista[i-1],sum(lista)+1):
for b in range(listb[i-1],sum(listb)+1):
dp[a][b][i]=min(dp[a][b][i-1],dp[a-lista[i-1]][b-listb[i-1]][i-1]+listc[i-1])
cost=float('inf')
for a in range(1,sum(lista)):
for b in range(1,sum(listb)):
if a*mb==b*ma:
cost=min(cost,dp[a][b][n])
if cost=float('inf'):
print(-1)
else:
print(cost) |
s775038101 | p03806 | u231685196 | 1524087440 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 720 | def gcd(a,b):
if a<b:
a,b = b,a
if b == 0:
return a
c = a%b
return gcd(b,c)
dp = []
dp.append({(0,0):0})
N,A,B = map(int,input().split())
for i in range(N):
a,b,c = map(int,input().split())
temp = dp[-1].copy()
for key in dp[-1].keys():
left = key[0] + a
right = key[1] + b
g = gcd(left, right)
if g != 1:
left = int(left/g)
right = int(right/g)
n_key = (left,right)
if not (n_key in temp):
temp[n_key] = dp[-1][key]+c
elif dp[-1][key]+c < dp[-1][n_key]:
temp[n_key] = dp[-1][key]+c
dp.append(temp)
if (A,B) in dp[N-1]:
print(dp[N-1][(A,B)])
else:
print(-1) |
s013012475 | p03806 | u231685196 | 1524087177 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 629 | import math
dp = []
dp.append({(0,0):0})
N,A,B = map(int,input().split())
for i in range(N):
a,b,c = map(int,input().split())
temp = dp[-1].copy()
for key in dp[-1].keys():
left = key[0] + a
right = key[1] + b
g = math.gcd(left, right)
if g != 1:
left = int(left/g)
right = int(right/g)
n_key = (left,right)
if not (n_key in temp):
temp[n_key] = dp[-1][key]+c
elif dp[-1][key]+c < dp[-1][n_key]:
temp[n_key] = dp[-1][key]+c
dp.append(temp)
if (A,B) in dp[N-1]:
print(dp[N-1][(A,B)])
else:
print(-1) |
s279440317 | p03806 | u391475811 | 1521690150 | Python | Python (3.4.3) | py | Runtime Error | 1613 | 82024 | 927 | N,Ma,Mb=map(int,input().split())
Med=[]
cnt_a=0
cnt_b=0
for i in range(N):
a=[int(x) for x in input().split()]
Med.append(a)
cnt_a+=a[0]
cnt_b+=a[1]
#[i]まででMa=[j],Mb=[k]を作る場合の最小のコストdp
#dp[i+1][j+Ma][k+Mb]=min(dp[i][j+Ma][k+Mb],dp[i][j][k]+Cost)
#リストをinfで初期化。inf=作れない配合なので、continue。初期値はdp[0][0][0]=0
dp=[[[float('inf') for j in range(cnt_b+1)] for k in range(cnt_a+1)] for i in range(N+1)]
dp[0][0][0]=0
for i in range(N):
for j in range(cnt_a+1):
for k in range(cnt_b+1):
if dp[i][j][k]==float('inf'):
continue
dp[i+1][j][k]=min(dp[i][j][k],dp[i+1][j][k])
dp[i+1][j+Med[i][0]][k+Med[i][1]]=min(dp[i][j+Med[i][0]][k+Med[i][1]],dp[i][j][k]+Med[i][2])
ans=float('inf')
for i in range(1,N+1):
if i*Ma<401 and i*Mb<401:
ans=min(ans,dp[N][i*Ma][i*Mb])
if ans==float('inf'):
print(-1)
else:
print(ans) |
s669379462 | p03806 | u785205215 | 1507671371 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1053 | from sys import stdin, setrecursionlimit
setrecursionlimit(10000)
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s828681264 | p03806 | u785205215 | 1507671307 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3064 | 1052 | from sys import stdin, setrecursionlimit
setrecursionlimit(5000)
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s066084990 | p03806 | u785205215 | 1507671243 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3064 | 1067 | from sys import stdin, setrecursionlimit
setrecursionlimit
setrecursionlimit(5000)
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s287137235 | p03806 | u785205215 | 1507671204 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1056 | from sys import stdin, stdout
setrecursionlimit
setrecursionlimit(5000)
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s668426759 | p03806 | u785205215 | 1507671148 | Python | PyPy3 (2.4.0) | py | Runtime Error | 173 | 38640 | 1014 | from sys import stdin, stdout
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s841556722 | p03806 | u785205215 | 1507670984 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1003 | from sys import stdin, stdout
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r == (Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s367362097 | p03806 | u785205215 | 1507649325 | Python | Python (3.4.3) | py | Runtime Error | 27 | 3700 | 1037 | from sys import stdin, stdout
from pprint import pprint
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r ==(Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])),ans):
return 0
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s378479669 | p03806 | u785205215 | 1507649216 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 997 | from sys import stdin, stdout
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r ==(Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])),ans):
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s001166997 | p03806 | u785205215 | 1507649144 | Python | Python (3.4.3) | py | Runtime Error | 27 | 3700 | 1025 | from sys import stdin, stdout
from pprint import pprint
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
def gcd(a, b):
while b:
a, b = b, a % b
return a
def ratio(a,b):
return (a//gcd(a,b), b//gcd(a,b))
def add_ratio(a,b):
if a != 0:
sum_a = sum(a)
sum_b = sum(b)
_a = a[0]*sum_b + b[0]*sum_a
_b = b[1]*sum_a + a[1]*sum_b
return ratio(_a, _b)
else:
return(b)
def dfs(i, v, r,ans):
if i == n:
if r ==(Ma,Mb):
ans.append(v)
return 0
if dfs(i+1, v, r,ans):
return 0
if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])),ans):
return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
e += i[2]
def main():
dfs(0,0,0,ans)
if ans:
print(min(ans))
else:
print(-1)
if __name__ == "__main__":
main() |
s291411882 | p03806 | u010110540 | 1506997508 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1020 | def solve():
INF = float('inf')
N, Ma, Mb = map(int, input().split())
l = []
for _ in range(N):
a,b,c = map(int, input().split())
l.append((a,b,c))
#dp table: dp[i][ca][cb]
dp = [[[INF] * 401 for _ in range(401)] for _ in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][a][b] != INF:
dp[i+1][a][b] = min(dp[i][a][b], dp[i+1][a][b]) #薬品iを加えない場合
dp[i+1][a+l[i][0]][b+l[i][1]] = min(dp[i+1][a+l[i][0]][b+l[i][1]], dp[i][a][b] + l[i][2]) #薬品iを加える場合
ans = INF
for i in range(N):
for ca in range(401):
for cb in range(401):
if dp[i][a][b] != INF:
if a * Mb == b * Ma:
ans = min(ans, dp[i][a][b])
print(-1 if ans == INF else ans)
if __name__ == '__main'__:
solve() |
s924860777 | p03806 | u683479402 | 1494464927 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 848 | # ABC54 D
n,ma,mb = map(int, input().split())
a = []
b = []
c = []
for i in range(N):
ai,bi,ci = map(int, input().split())
a.append(ai)
b.append(bi)
c.append(ci)
max_sum = n * 10
max_cost = 100000000
dp = [[[max_cost for k in range(max_sum+1)] for j in range(max_sum+1)] for i in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
for ca in range(max_sum+1):
for cb in range(max_sum+1):
if(dp[i][ca][cb] == max_cost):
continue
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
dp[i+1][ca+a[i]][cb+b[i]] = min(dp[i+1][ca+a[i]][cb+b[i]], dp[i][ca][cb]+c[i])
ans = max_cost
for ca in range(1,max_sum+1):
for cb in range(1,max_sum+1):
if(ca*mb == cb*ma):
ans = min(ans, dp[n][ca][cb])
if(ans == max_cost):
print(-1)
else:
print(ans) |
s944875373 | p03806 | u683479402 | 1494464519 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3192 | 844 | # ABC54 D
n,ma,mb = map(int, input().split())
a = []
b = []
c = []
for i in range(N):
ai,bi,ci = map(int, input().split())
a.append(ai)
b.append(bi)
c.append(ci)
max_sum = n * 10
max_cost = 100000000
dp = [[[max_cost for k in range(n+1)] for j in range(max_sum+1)] for i in range(max_sum+1)]
dp[0][0][0] = 0
for i in range(n):
for ca in range(max_sum+1):
for cb in range(max_sum+1):
if(dp[i][ca][cb] == max_cost):
continue
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
dp[i+1][ca+a[i]][cb+b[i]] = min(dp[i+1][ca+a[i]][cb+b[i]], dp[i][ca][cb]+c[i])
ans = max_cost
for ca in range(max_sum+1):
for cb in range(max_sum+1):
if(ca*mb == cb*ma):
ans = min(ans, dp[n][ca][cb])
if(ans == max_cost):
print(-1)
else:
print(ans) |
s793797912 | p03806 | u683479402 | 1494464518 | Python | Python (3.4.3) | py | Runtime Error | 25 | 3444 | 844 | # ABC54 D
n,ma,mb = map(int, input().split())
a = []
b = []
c = []
for i in range(N):
ai,bi,ci = map(int, input().split())
a.append(ai)
b.append(bi)
c.append(ci)
max_sum = n * 10
max_cost = 100000000
dp = [[[max_cost for k in range(n+1)] for j in range(max_sum+1)] for i in range(max_sum+1)]
dp[0][0][0] = 0
for i in range(n):
for ca in range(max_sum+1):
for cb in range(max_sum+1):
if(dp[i][ca][cb] == max_cost):
continue
dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
dp[i+1][ca+a[i]][cb+b[i]] = min(dp[i+1][ca+a[i]][cb+b[i]], dp[i][ca][cb]+c[i])
ans = max_cost
for ca in range(max_sum+1):
for cb in range(max_sum+1):
if(ca*mb == cb*ma):
ans = min(ans, dp[n][ca][cb])
if(ans == max_cost):
print(-1)
else:
print(ans) |
s620441783 | p03806 | u712187387 | 1487022583 | Python | Python (3.4.3) | py | Runtime Error | 22 | 3064 | 512 | import itertools
import numpy as np
N,Ma,Mb=map(int,input().split())
yaku=[]
for _ in range(N):
yaku.append(list(map(int,input().split())))
candi_money=[]
for n in range(N):
candis=list(itertools.combinations(np.arange(N),n))
for candi in candis:
a,b,c=0,0,0
for num in candi:
a +=yaku[num][0]
b +=yaku[num][1]
c +=yaku[num][2]
if a/flaot(Ma/Mb)=b:
candi_money.append(c)
if len(candi_money)==0:
print(-1)
else:
print(min(candi_money)) |
s491728568 | p03806 | u210440747 | 1486894842 | Python | Python (3.4.3) | py | Runtime Error | 368 | 27380 | 1008 | import numpy as np
import copy
if __name__=="__main__":
inputs_number = lambda : [int(x) for x in input().split()]
N, Ma, Mb = inputs_number()
drugs = [inputs_number() for i in range(N)]
inf = 100*N + 1
dp = np.ones((2,N*10+1,N*10+1)).astype(np.int32) * inf
dp = dp.tolist()
dp[0][0][0] = 0.0
for i in range(N):
for ca in range(N*i+1):
for cb in range(N*i+1):
if(dp[0][ca][cb]==inf):
continue
dp[1][ca][cb]=min([dp[1][ca][cb], dp[0][ca][cb]])
dp[1][ca+drugs[i][0]][cb+drugs[i][1]]=min([dp[1][ca+drugs[i][0]][cb+drugs[i][1]], dp[0][ca][cb]+drugs[i][2]])
dp[0] = copy.copy(dp[1])
dp[1] = (np.ones((N*10+1,N*10+1)).astype(np.int32) * inf).tolist()
ans = inf
for ca in range(1, N*10+1):
for cb in range(1, N*10+1):
if(Ma*cb==Mb*ca and dp[0][ca][cb]<ans):
ans = dp[0][ca][cb]
if(ans==inf):
ans = -1
print(int(ans)) |
s260993299 | p03806 | u210440747 | 1486894038 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3064 | 908 | import numpy as np
if __name__=="__main__":
inputs_number = lambda : [int(x) for x in input().split()]
N, Ma, Mb = inputs_number()
drugs = [inputs_number() for i in range(N)]
inf = 100*N + 1
dp = np.ones((N+1,N*10+1,N*10+1)).astype(np.int32) * inf
dp = dp.tolist()
dp[0][0][0] = 0.0
for i in range(N):
for ca in range(N*(i+1)+1):
for cb in range(N*(i+1)+1):
if(dp[i][ca][cb]==inf):
continue
dp[i+1][ca][cb]=min([dp[i+1][ca][cb], dp[i][ca][cb]])
dp[i+1][ca+drugs[i][0]][cb+drugs[i][1]]=min([dp[i+1][ca+drugs[i][0]][c\
b+drugs[i][1]], dp[i][ca][cb]+drugs[i][2]])
ans = inf
for ca in range(1, N*10+1):
for cb in range(1, N*10+1):
if(Ma*cb==Mb*ca and dp[N][ca][cb]<ans):
ans = dp[N][ca][cb]
if(ans==inf):
ans = -1
print(int(ans)) |
s085790355 | p03806 | u210440747 | 1486893863 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3064 | 891 | import numpy as np
if __name__=="__main__":
inputs_number = lambda : [int(x) for x in input().split()]
N, Ma, Mb = inputs_number()
drugs = [inputs_number() for i in range(N)]
inf = 100*N + 1
dp = np.ones((N+1,N*10+1,N*10+1)).astype(np.int32) * inf
dp = dp.tolist()
dp[0][0][0] = 0.0
for i in range(N):
for ca in range(N*i+1):
for cb in range(N*i+1):
if(dp[i][ca][cb]==inf):
continue
dp[i+1][ca][cb]=min([dp[i+1][ca][cb], dp[i][ca][cb]])
dp[i+1][ca+drugs[i][0]][cb+drugs[i][1]]=min([dp[i+1][ca+drugs[i][0]][cb+drugs[i][1]], dp[i][ca][cb]+drugs[i][2]])
ans = inf
for ca in range(1, N*10+1):
for cb in range(1, N*10+1):
if(Ma*cb==Mb*ca and dp[N][ca][cb]<ans):
ans = dp[N][ca][cb]
if(ans==inf):
ans = -1
print(int(ans)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.