input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for x in 0,1,2,3:
for z in range(k):
y=0,~z,0,z+1;i,j=s//w+y[x],s%w+y[~x];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for x in 0,1,2,3:
for z in range(k):
y=z+1,0,~z,0;i,j=s//w+y[x],s%w+y[~x];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
import sys
from collections import deque
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
h, w, k = map(int, input().strip().split())
x1, y1, x2, y2 = map(int, input().strip().split())
x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1
m = []
costs1 = [[None for j in range(w)] for i in range(h)]
costs2 = [[None for j in range(w)] for i in range(h)]
for _ in range(h):
m.append(list(input().strip()))
q1 = deque()
q1.append((x1, y1, 0))
costs1[x1][y1] = 0
q2 = deque()
q2.append((x2, y2, 0))
costs2[x2][y2] = 0
directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
while q1 and q2:
(x, y, cost) = q1.popleft()
if not costs2[x][y] is None:
print(cost + costs2[x][y])
return
for (add_x, add_y) in directions:
for dist in range(1, k + 1):
new_x = x + add_x * dist
new_y = y + add_y * dist
if new_x >= h or new_x < 0 or new_y >= w or new_y < 0 or m[new_x][new_y] == '@':
break
if costs1[new_x][new_y] is None:
costs1[new_x][new_y] = cost + 1
q1.append((new_x, new_y, cost + 1))
(x, y, cost) = q2.popleft()
if not costs1[x][y] is None:
print(cost + costs1[x][y])
return
for (add_x, add_y) in directions:
for dist in range(1, k + 1):
new_x = x + add_x * dist
new_y = y + add_y * dist
if new_x >= h or new_x < 0 or new_y >= w or new_y < 0 or m[new_x][new_y] == '@':
break
if costs2[new_x][new_y] is None:
costs2[new_x][new_y] = cost + 1
q2.append((new_x, new_y, cost + 1))
print("-1")
if __name__ == '__main__':
main()
| import sys
from collections import deque
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
h, w, k = map(int, input().strip().split())
x1, y1, x2, y2 = map(int, input().strip().split())
x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1
m = []
costs1 = [[None for j in range(w)] for i in range(h)]
costs2 = [[None for j in range(w)] for i in range(h)]
for _ in range(h):
m.append(list(input().strip()))
q1 = deque()
q1.append((x1, y1, 0))
costs1[x1][y1] = 0
q2 = deque()
q2.append((x2, y2, 0))
costs2[x2][y2] = 0
directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
while q1 and q2:
(x, y, cost) = q1.popleft()
if not costs2[x][y] is None:
print(cost + costs2[x][y])
return
for (add_x, add_y) in directions:
for dist in range(1, k + 1):
new_x = x + add_x * dist
new_y = y + add_y * dist
if new_x >= h or new_x < 0 or new_y >= w or new_y < 0 or m[new_x][new_y] == '@' or ((not costs1[new_x][new_y] is None) and costs1[new_x][new_y] < cost + 1):
break
if costs1[new_x][new_y] is None:
costs1[new_x][new_y] = cost + 1
q1.append((new_x, new_y, cost + 1))
(x, y, cost) = q2.popleft()
if not costs1[x][y] is None:
print(cost + costs1[x][y])
return
for (add_x, add_y) in directions:
for dist in range(1, k + 1):
new_x = x + add_x * dist
new_y = y + add_y * dist
if new_x >= h or new_x < 0 or new_y >= w or new_y < 0 or m[new_x][new_y] == '@' or ((not costs2[new_x][new_y] is None) and costs2[new_x][new_y] < cost + 1):
break
if costs2[new_x][new_y] is None:
costs2[new_x][new_y] = cost + 1
q2.append((new_x, new_y, cost + 1))
print("-1")
if __name__ == '__main__':
main()
| p02644 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import collections
import sys
INF = 10**10
def main(H, W, K, x1, y1, x2, y2, C):
dist = [[INF] * W for _ in range(H)]
q = collections.deque([(x1, y1)])
dist[x1][y1] = 0
while q:
i, j = q.popleft()
d = dist[i][j]
for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
for dt in range(1, K + 1):
ni, nj = i + di * dt, j + dj * dt
if not (0 <= ni < H and 0 <= nj < W): break
if C[ni][nj] == '@': break
if dist[ni][nj] <= d + 1: continue
dist[ni][nj] = d + 1
q.append((ni, nj))
ans = dist[x2][y2]
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x) - 1 for x in input().split()]
C = [input().rstrip() for _ in range(H)]
main(H, W, K, x1, y1, x2, y2, C)
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import collections
import sys
INF = 10**10
def main(H, W, K, x1, y1, x2, y2, C):
dist = [[INF] * W for _ in range(H)]
q = collections.deque([(x1, y1)])
dist[x1][y1] = 0
while q:
i, j = q.popleft()
d = dist[i][j]
for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
for dt in range(1, K + 1):
ni, nj = i + di * dt, j + dj * dt
if not (0 <= ni < H and 0 <= nj < W): break
if C[ni][nj] == '@': break
if dist[ni][nj] == d + 1: continue
if dist[ni][nj] < d + 1: break
dist[ni][nj] = d + 1
q.append((ni, nj))
ans = dist[x2][y2]
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x) - 1 for x in input().split()]
C = [input().rstrip() for _ in range(H)]
main(H, W, K, x1, y1, x2, y2, C)
| p02644 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from heapq import heappush, heappop
import sys
INF = 10**10
def main(H, W, K, x1, y1, x2, y2, C):
dist = [[INF] * W for _ in range(H)]
q = [(0, x1, y1)]
dist[x1][y1] = 0
while q:
d, i, j = heappop(q)
if dist[i][j] < d: continue
for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
for dt in range(1, K + 1):
ni, nj = i + di * dt, j + dj * dt
if not (0 <= ni < H and 0 <= nj < W): break
if C[ni][nj] == '@': break
if dist[ni][nj] <= d + 1: continue
heappush(q, (d + 1, ni, nj))
dist[ni][nj] = d + 1
ans = dist[x2][y2]
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x) - 1 for x in input().split()]
C = [input().rstrip() for _ in range(H)]
main(H, W, K, x1, y1, x2, y2, C)
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from heapq import heappush, heappop
import sys
INF = 10**10
def main(H, W, K, x1, y1, x2, y2, C):
dist = [[INF] * W for _ in range(H)]
q = [(0, x1, y1)]
dist[x1][y1] = 0
while q:
d, i, j = heappop(q)
if dist[i][j] < d: continue
for di, dj in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
for dt in range(1, K + 1):
ni, nj = i + di * dt, j + dj * dt
if not (0 <= ni < H and 0 <= nj < W): break
if C[ni][nj] == '@': break
if dist[ni][nj] == d + 1: continue
if dist[ni][nj] < d + 1: break
heappush(q, (d + 1, ni, nj))
dist[ni][nj] = d + 1
ans = dist[x2][y2]
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x) - 1 for x in input().split()]
C = [input().rstrip() for _ in range(H)]
main(H, W, K, x1, y1, x2, y2, C)
| p02644 |
import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
H, W, K = list(map(int, rl().split()))
sy, sx, gy, gx = [int(n) - 1 for n in rl().split()]
c = [rl().rstrip() for _ in range(H)]
INF = 10 ** 10
cost = [[INF] * W for _ in range(H)]
cost[sy][sx] = 0
que = deque([(sy, sx)])
while que:
cy, cx = que.popleft()
for dy, dx in ((-1, 0), (0, 1), (1, 0), (0, -1)):
for k in range(1, K + 1):
ny, nx = cy + k * dy, cx + k * dx
if 0 <= ny < H and 0 <= nx < W:
if c[ny][nx] == '@':
break
if cost[ny][nx] <= cost[cy][cx]:
break
cost[ny][nx] = cost[cy][cx] + 1
que.append((ny, nx))
print((cost[gy][gx] if cost[gy][gx] != INF else -1))
if __name__ == '__main__':
solve()
| import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
H, W, K = list(map(int, rl().split()))
sy, sx, gy, gx = [int(n) - 1 for n in rl().split()]
c = [rl().rstrip() for _ in range(H)]
INF = 10 ** 10
cost = [[INF] * W for _ in range(H)]
cost[sy][sx] = 0
que = deque([(sy, sx)])
while que:
cy, cx = que.popleft()
for dy, dx in ((-1, 0), (0, 1), (1, 0), (0, -1)):
for k in range(1, K + 1):
ny, nx = cy + k * dy, cx + k * dx
if 0 <= ny < H and 0 <= nx < W:
if c[ny][nx] == '@':
break
if cost[ny][nx] <= cost[cy][cx]:
break
ncost = cost[cy][cx] + 1
if ncost < cost[ny][nx]:
cost[ny][nx] = ncost
que.append((ny, nx))
print((cost[gy][gx] if cost[gy][gx] != INF else -1))
if __name__ == '__main__':
solve()
| p02644 |
h,w,k=map(int,input().split())
r,s,t,u=map(lambda x:int(x)-1,input().split())
b=[input()for _ in range(h)]
l=[[-1]*w for _ in range(h)]
l[r][s]=0
from collections import*
d=deque([(r,s)])
while d:
x,y=d.popleft()
if(x==t)&(y==u):exit(print(l[x][y]))
for e,f in [[1,0],[-1,0],[0,-1],[0,1]]:
for i in range(1,k+1):
p,q=x+e*i,y+f*i
if not(0<=p<h and 0<=q<w)or b[p][q]=="@":break
if 0<=l[p][q]<=l[x][y]:break
if l[p][q]==-1:d+=[(p,q)]
l[p][q]=l[x][y]+1
print(-1)
| h,w,k=map(int,input().split())
r,s,t,u=map(lambda x:int(x)-1,input().split())
b=[input()for _ in range(h)]
l=[[-1]*w for _ in range(h)]
l[r][s]=0
from collections import*
d=deque([(r,s)])
while d:
x,y=d.popleft()
if(x==t)&(y==u):exit(print(l[x][y]))
for e,f in[[1,0],[-1,0],[0,-1],[0,1]]:
for i in range(1,k+1):
p,q=x+e*i,y+f*i
if not((0<=p<h)&(0<=q<w))or b[p][q]=="@":break
if 0<=l[p][q]<=l[x][y]:break
if l[p][q]==-1:d+=[(p,q)];l[p][q]=l[x][y]+1
print(-1)
| p02644 |
z,v,a=input,range,print
h,w,k=map(int,z().split())
r,s,t,u=map(lambda x:int(x)-1,z().split())
b=[z()for _ in v(h)]
l=[[-1]*w for _ in v(h)]
l[r][s]=0
from collections import*
d=deque([(r,s)])
while d:
x,y=d.popleft()
if(x==t)&(y==u):exit(a(l[x][y]))
for e,f in[[1,0],[-1,0],[0,-1],[0,1]]:
for i in v(1,k+1):
p,q=x+e*i,y+f*i
if not((0<=p<h)&(0<=q<w))or b[p][q]=="@" or 0<=l[p][q]<=l[x][y]:break
d+=[(p,q)];l[p][q]=l[x][y]+1
a(-1)
| from collections import*
z,v,a=input,range,print
h,w,k=map(int,z().split());r,s,t,u=map(lambda x:int(x)-1,z().split())
b=[z()for _ in v(h)];l=[[-1]*w for _ in v(h)];l[r][s]=0
d=deque([(r,s)])
while d:
x,y=d.popleft()
if(x==t)&(y==u):exit(a(l[x][y]))
for e,f in[[1,0],[-1,0],[0,-1],[0,1]]:
for i in v(1,k+1):
p,q=x+e*i,y+f*i
if not((0<=p<h)&(0<=q<w))or b[p][q]=="@" or 0<=l[p][q]<=l[x][y]:break
if l[p][q]<0:d+=[(p,q)];l[p][q]=l[x][y]+1
a(-1)
| p02644 |
from collections import*
z,v,a=input,range,print
h,w,k=map(int,z().split());r,s,t,u=map(lambda x:int(x)-1,z().split())
b=[z()for _ in v(h)];l=[[-1]*w for _ in v(h)];l[r][s]=0
d=deque([(r,s)])
while d:
x,y=d.popleft()
if(x==t)&(y==u):exit(a(l[x][y]))
for e,f in[[1,0],[-1,0],[0,-1],[0,1]]:
for i in v(1,k+1):
p,q=x+e*i,y+f*i
if not((0<=p<h)&(0<=q<w))or b[p][q]=="@" or 0<=l[p][q]<=l[x][y]:break
if l[p][q]<0:d+=[(p,q)];l[p][q]=l[x][y]+1
a(-1)
| from collections import*
z,v,a=input,range,print
h,w,k=map(int,z().split());r,s,t,u=map(lambda x:int(x)-1,z().split())
b=[z()for _ in v(h)];l=[[-1]*w for _ in v(h)];l[r][s]=0
d=deque([(r,s)])
while d:
x,y=d.popleft();j=l[x][y]
if(x==t)&(y==u):exit(a(j))
for e,f in[[1,0],[-1,0],[0,-1],[0,1]]:
for i in v(1,k+1):
p,q=x+e*i,y+f*i
if not((0<=p<h)&(0<=q<w))or b[p][q]=="@" or 0<=l[p][q]<=j:break
if l[p][q]<0:d+=[(p,q)];l[p][q]=j+1
a(-1)
| p02644 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 1 2
0 2 1
1 2 1
1 3 1
2 3 2
output:
3
"""
import sys
from collections import deque
def graph_bfs(source, target, parent):
visited = [False] * vertices
queue = deque()
queue.append(source)
visited[source] = True
while queue:
current = queue.popleft()
for adj, cp in list(adj_table[current].items()):
if not visited[adj] and cp:
queue.append(adj)
visited[adj] = True
parent[adj] = current
return True if visited[target] else False
def graphFordFulkerson(source, sink):
parent = [-1] * vertices
max_flow = 0
while graph_bfs(source, sink, parent):
path_flow = float('inf')
end = sink
while end is not source:
path_flow = min(path_flow, adj_table[parent[end]][end])
end = parent[end]
max_flow += path_flow
cursor = sink
while cursor is not source:
c_parent = parent[cursor]
# print(c_parent, cursor, path_flow)
adj_table[c_parent].setdefault(cursor, -1)
adj_table[cursor].setdefault(c_parent, -1)
adj_table[c_parent][cursor] -= path_flow
adj_table[cursor][c_parent] += path_flow
cursor = parent[c_parent]
return max_flow
def generate_adj_table(v_table):
for each in v_table:
source, target, cp = list(map(int, each))
init_adj_table[source][target] = cp
return init_adj_table
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
init_adj_table = [dict() for _ in range(vertices)]
adj_table = generate_adj_table(v_info)
ans = graphFordFulkerson(source=0, sink=vertices - 1)
print(ans) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 1 2
0 2 1
1 2 1
1 3 1
2 3 2
output:
3
"""
import sys
from collections import deque
def graph_bfs(source, target, parent):
visited = [False] * vertices
queue = deque()
queue.append(source)
visited[source] = True
while queue:
current = queue.popleft()
for adj, cp in list(adj_table[current].items()):
if not visited[adj] and cp > 0:
queue.append(adj)
visited[adj] = True
parent[adj] = current
return True if visited[target] else False
def graphFordFulkerson(source, sink):
parent = [-1] * vertices
max_flow = 0
while graph_bfs(source, sink, parent):
path_flow = float('inf')
bk_1 = sink
while bk_1 != source:
path_flow = min(path_flow, adj_table[parent[bk_1]][bk_1])
bk_1 = parent[bk_1]
max_flow += path_flow
bk_2 = sink
while bk_2 != source:
parent_bk_2 = parent[bk_2]
adj_table[parent_bk_2].setdefault(bk_2, 0)
adj_table[bk_2].setdefault(parent_bk_2, 0)
# print(bk_2, parent_bk_2, path_flow, bk_1, parent[bk_1], parent, adj_table)
adj_table[parent_bk_2][bk_2] -= path_flow
adj_table[bk_2][parent_bk_2] += path_flow
bk_2 = parent[bk_2]
return max_flow
def generate_adj_table(v_table):
for each in v_table:
source, target, cp = list(map(int, each))
init_adj_table[source][target] = cp
return init_adj_table
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
init_adj_table = [dict() for _ in range(vertices)]
adj_table = generate_adj_table(v_info)
ans = graphFordFulkerson(source=0, sink=vertices - 1)
print(ans) | p02376 |
# Acceptance of input
import sys
file_input = sys.stdin
V, E = list(map(int, file_input.readline().split()))
adj_mat = [[0] * V for i in range(V)]
for line in file_input:
u, v, c = list(map(int, line.split()))
adj_mat[u][v] = c
# Ford???Fulkerson algorithm
import collections
# BFS for residual capacity network
def bfs(start, goal, parent):
unvisited = [True] * V
queue = collections.deque()
queue.append(start)
unvisited[start] = False
while queue:
u = queue.popleft()
for v, flow in enumerate(adj_mat[u]):
if unvisited[v] and (flow > 0):
queue.append(v)
unvisited[v] = False
parent[v] = u
return not unvisited[goal]
def ford_fulkerson(source, sink):
parent = [None] * V
max_flow = 0
while bfs(source, sink, parent):
aug_path_flow = 10000
v = sink
while (v != source):
aug_path_flow = min(aug_path_flow, adj_mat[parent[v]][v])
v = parent[v]
max_flow += aug_path_flow
v = sink
while (v != source):
u = parent[v]
adj_mat[u][v] -= aug_path_flow
adj_mat[v][u] += aug_path_flow
v = u
return max_flow
# output
print((ford_fulkerson(0, V - 1))) | # Acceptance of input
import sys
file_input = sys.stdin
V, E = list(map(int, file_input.readline().split()))
adj_mat = [[0] * V for i in range(V)]
for line in file_input:
u, v, c = list(map(int, line.split()))
adj_mat[u][v] = c
# Ford???Fulkerson algorithm
import collections
# BFS for residual capacity network
def bfs(start, goal, parent):
flow = [0] * V
queue = collections.deque()
queue.append(start)
flow[start] = 10000
while queue:
u = queue.popleft()
for v, r_capacity in enumerate(adj_mat[u]):
if not flow[v] and (r_capacity > 0):
queue.append(v)
flow[v] = min(flow[u], r_capacity)
parent[v] = u
if v == goal:
return flow[goal]
def ford_fulkerson(source, sink):
max_flow = 0
while True:
parent = [None] * V
aug_path_flow = bfs(source, sink, parent)
if aug_path_flow:
max_flow += aug_path_flow
v = sink
while (v != source):
u = parent[v]
adj_mat[u][v] -= aug_path_flow
adj_mat[v][u] += aug_path_flow
v = u
else:
break
return max_flow
# output
print((ford_fulkerson(0, V - 1))) | p02376 |
from collections import deque
class Edge:
def __init__(self, to, rev, cap):
self.to = to
self.rev = rev
self.cap = cap
# 最大流問題を解く O(|E||V|^2)
class Dinic:
def __init__(self, num_of_node: int):
assert num_of_node > 0
self.graph = [list() for _ in range(num_of_node)] # グラフの隣接リスト表現
self.level = [None] * num_of_node # sからの距離
self.ite = [None] * num_of_node # どこまで調べ終わったか
# fromからtoへ向かう容量capの辺をグラフに追加する
def add_edge(self, f: int, t: int, cap: int):
self.graph[f].append(Edge(t, len(self.graph[t]), cap))
self.graph[t].append(Edge(f, len(self.graph[f]) - 1, 0))
# sからtへの最大流を求める
def max_flow(self, s: int, t: int):
flow = 0
while True:
self.bfs(s)
if self.level[t] < 0:
return flow
self.ite = [0] * len(self.ite)
while True:
f = self.dfs(s, t, 10 ** 10)
if f > 0:
flow += f
else:
break
# sからの最短距離をBFSで計算する
def bfs(self, s: int):
self.level = [-1] * len(self.level)
que = deque()
que.append(s)
self.level[s] = 0
while len(que):
v = que.popleft()
for i in range(len(self.graph[v])):
e = self.graph[v][i]
if e.cap > 0 and self.level[e.to] < 0:
self.level[e.to] = self.level[v] + 1
que.append(e.to)
# 増加パスをDFSで探す
def dfs(self, v: int, t: int, f: int):
if v == t:
return f
for i in range(0, len(self.graph[v])):
e = self.graph[v][i]
if e.cap > 0 and self.level[v] < self.level[e.to]:
d = self.dfs(e.to, t, min(f, e.cap))
if d > 0:
self.graph[v][i].cap -= d
self.graph[e.to][e.rev].cap += d
return d
self.ite[v] = i
return 0
def main():
V, E = list(map(int, input().split()))
dinic = Dinic(V)
for _ in range(E):
u, v, c = list(map(int, input().split()))
dinic.add_edge(u, v, c)
print((dinic.max_flow(0, V - 1)))
if __name__ == '__main__':
main()
| from collections import deque
class Edge:
def __init__(self, to, flow, cap, rev, is_rev):
self.to = to
self.flow = flow
self.cap = cap
self.rev = rev
self.is_rev = is_rev
class Dinic:
def __init__(self, num_of_node: int):
assert num_of_node > 0
self.graph = [list() for _ in range(num_of_node)] # グラフの隣接リスト表現
self.level = [None] * num_of_node # sからの距離
self.ite = [None] * num_of_node # どこまで調べ終わったか
# fromからtoへ向かう容量capの辺をグラフに追加する
def add_edge(self, f: int, t: int, cap: int):
self.graph[f].append(Edge(t, 0, cap, len(self.graph[t]), False))
self.graph[t].append(Edge(f, cap, cap, len(self.graph[f]) - 1, True))
# sからtへの最大流を求める
def max_flow(self, s: int, t: int):
flow = 0
while True:
self.bfs(s)
if self.level[t] < 0:
return flow
self.ite = [0] * len(self.ite)
while True:
f = self.dfs(s, t, 10 ** 10)
if f > 0:
flow += f
else:
break
# sからの最短距離をBFSで計算する
def bfs(self, s: int):
self.level = [-1] * len(self.level)
que = deque()
que.append(s)
self.level[s] = 0
while len(que):
v = que.popleft()
for i in range(len(self.graph[v])):
e = self.graph[v][i]
if e.cap - e.flow > 0 and self.level[e.to] < 0:
self.level[e.to] = self.level[v] + 1
que.append(e.to)
# 増加パスをDFSで探す
def dfs(self, v: int, t: int, f: int):
if v == t:
return f
for i in range(self.ite[v], len(self.graph[v])):
e = self.graph[v][i]
if e.cap - e.flow > 0 and self.level[v] < self.level[e.to]:
d = self.dfs(e.to, t, min(f, e.cap - e.flow))
if d > 0:
self.graph[v][i].flow += d
self.graph[e.to][e.rev].flow -= d
return d
self.ite[v] = i
return 0
def main():
V, E = list(map(int, input().split()))
dinic = Dinic(V)
for _ in range(E):
u, v, c = list(map(int, input().split()))
dinic.add_edge(u, v, c)
print((dinic.max_flow(0, V - 1)))
if __name__ == '__main__':
main()
| p02376 |
import sys
from collections import deque
class MaxFlow:
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, node_size, inf):
self._node = node_size
self._inf = inf
self._level = [-1]*self._node
self._iter = [0]*self._node
self._graph = [[] for _ in range(self._node)]
def add_edge(self, from_, to, cap):
self._graph[from_].append(self.Edge(to, cap, len(self._graph[to])))
self._graph[to].append(self.Edge(from_, 0, len(self._graph[from_])-1))
def bfs(self, start):
for i in range(self._node):
self._level[i] = -1
que = deque()
self._level[start] = 0
que.append(start)
while que:
cur_vertex = que.popleft()
for e in self._graph[cur_vertex]:
if self._level[e.to] < 0 < e.cap:
self._level[e.to] = self._level[cur_vertex] + 1
que.append(e.to)
def dfs(self, cur_vertex, end_vertex, flow):
if cur_vertex == end_vertex:
return flow
for e in self._graph[cur_vertex][self._iter[cur_vertex]:len(self._graph[cur_vertex])]:
if e.cap > 0 and self._level[cur_vertex] < self._level[e.to]:
flowed = self.dfs(e.to, end_vertex, min(flow, e.cap))
if flowed > 0:
e.cap -= flowed
self._graph[e.to][e.rev].cap += flowed
return flowed
return 0
def solve(self, source, sink):
flow = 0
while True:
self.bfs(source)
if self._level[sink] < 0:
return flow
for i in range(self._node):
self._iter[i] = 0
while True:
f = self.dfs(source, sink, self._inf)
if f == 0:
break
flow += f
def main():
n, m = list(map(int, sys.stdin.readline().split()))
mf = MaxFlow(n, 10 ** 4)
for _ in range(m):
u, v, c = list(map(int, sys.stdin.readline().split()))
mf.add_edge(u, v, c)
print((mf.solve(0, n - 1)))
if __name__ == '__main__':
main()
| import sys
from collections import deque
class MaxFlow:
class Edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, node_size, inf):
self._node = node_size
self._inf = inf
self._level = [-1]*self._node
self._iter = [0]*self._node
self._graph = [[] for _ in range(self._node)]
def add_edge(self, from_, to, cap):
self._graph[from_].append(self.Edge(to, cap, len(self._graph[to])))
self._graph[to].append(self.Edge(from_, 0, len(self._graph[from_])-1))
def bfs(self, start):
self._level = [-1]*self._node
que = deque()
self._level[start] = 0
que.append(start)
while que:
cur_vertex = que.popleft()
for e in self._graph[cur_vertex]:
if e.cap > 0 > self._level[e.to]:
self._level[e.to] = self._level[cur_vertex] + 1
que.append(e.to)
def dfs(self, cur_vertex, end_vertex, flow):
if cur_vertex == end_vertex:
return flow
while self._iter[cur_vertex] < len(self._graph[cur_vertex]):
e = self._graph[cur_vertex][self._iter[cur_vertex]]
if e.cap > 0 and self._level[cur_vertex] < self._level[e.to]:
flowed = self.dfs(e.to, end_vertex, min(flow, e.cap))
if flowed > 0:
e.cap -= flowed
self._graph[e.to][e.rev].cap += flowed
return flowed
self._iter[cur_vertex] += 1
return 0
def solve(self, source, sink):
flow = 0
while True:
self.bfs(source)
if self._level[sink] < 0:
return flow
self._iter = [0]*self._node
while True:
f = self.dfs(source, sink, self._inf)
if f == 0:
break
flow += f
if __name__ == '__main__':
n, m = list(map(int, sys.stdin.readline().split()))
mf = MaxFlow(n, 10**10)
for _ in range(m):
u, v, c = list(map(int, sys.stdin.readline().split()))
mf.add_edge(u, v, c)
print((mf.solve(0, n-1)))
| p02376 |
from collections import deque
class Dinic:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
"""
class edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, E, source, sink):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
for fr in range(V):
for to, cap in E[fr]:
self.E[fr].append(self.edge(to, cap, len(self.E[to])))
self.E[to].append(self.edge(fr, 0, len(self.E[fr])-1))
self.maxflow = self.dinic(source, sink)
def dinic(self, source, sink):
"""find max-flow"""
INF = float('inf')
maxflow = 0
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = [0] * self.V
while True:
flow = self.dfs(source, sink, INF)
if flow > 0:
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[v], len(self.E[vertex])):
self.itr[v] = i
e = self.E[vertex][i]
if e.cap > 0 and self.level[vertex] < self.level[e.to]:
d = self.dfs(e.to, sink, min(flow, e.cap))
if d > 0:
self.E[vertex][i].cap -= d
self.E[e.to][e.rev].cap += d
return d
return 0
def bfs(self, start):
"""find shortest path from start"""
que = deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > 0 and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
u, v, cap = list(map(int, input().split()))
edge[u].append((v, cap))
print((Dinic(V, edge, 0, V-1).maxflow)) | from collections import deque
class Dinic:
"""Dinic Algorithm: find max-flow
complexity: O(EV^2)
"""
class edge:
def __init__(self, to, cap, rev):
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, V, E, source, sink):
""" V: the number of vertexes
E: adjacency list
source: start point
sink: goal point
"""
self.V = V
self.E = [[] for _ in range(V)]
for fr in range(V):
for to, cap in E[fr]:
self.E[fr].append(self.edge(to, cap, len(self.E[to])))
self.E[to].append(self.edge(fr, 0, len(self.E[fr])-1))
self.maxflow = self.dinic(source, sink)
def dinic(self, source, sink):
"""find max-flow"""
INF = float('inf')
maxflow = 0
while True:
self.bfs(source)
if self.level[sink] < 0:
return maxflow
self.itr = [0] * self.V
while True:
flow = self.dfs(source, sink, INF)
if flow > 0:
maxflow += flow
else:
break
def dfs(self, vertex, sink, flow):
"""find augmenting path"""
if vertex == sink:
return flow
for i in range(self.itr[vertex], len(self.E[vertex])):
self.itr[vertex] = i
e = self.E[vertex][i]
if e.cap > 0 and self.level[vertex] < self.level[e.to]:
d = self.dfs(e.to, sink, min(flow, e.cap))
if d > 0:
self.E[vertex][i].cap -= d
self.E[e.to][e.rev].cap += d
return d
return 0
def bfs(self, start):
"""find shortest path from start"""
que = deque()
self.level = [-1] * self.V
que.append(start)
self.level[start] = 0
while que:
fr = que.popleft()
for e in self.E[fr]:
if e.cap > 0 and self.level[e.to] < 0:
self.level[e.to] = self.level[fr] + 1
que.append(e.to)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
u, v, cap = list(map(int, input().split()))
edge[u].append((v, cap))
print((Dinic(V, edge, 0, V-1).maxflow)) | p02376 |
from sys import stdin
from collections import defaultdict
readline = stdin.readline
#readline = open('???.txt').readline
def main():
v, e = list(map(int, readline().split()))
g = defaultdict(list)
residual = [[0] * v for _ in range(v)]
source, sink = 0, v - 1
for _ in range(e):
s, t, c = list(map(int, readline().split()))
if 0 < c:
g[s].append(t)
g[t].append(s)
residual[s][t] = c
capacity = sum(residual[source][i] for i in g[source])
while True:
route, flow = search(g, residual, source, sink)
if route is None:
break
for i in range(1, len(route)):
residual[route[i - 1]][route[i]] -= flow
residual[route[i]][route[i - 1]] += flow
print((capacity - sum(residual[source][i] for i in g[source])))
def search(g, residual, source, sink):
dfs_stack = [(source, None, float('inf'))]
route = [None]
visited = set()
while dfs_stack:
u, prev, flow = dfs_stack.pop()
while route[-1] != prev:
route.pop()
route.append(u)
visited |= {u}
if u == sink:
return route[1:], flow
for v in g[u]:
if v in route:
continue
next_flow = min(residual[u][v], flow)
if 0 < next_flow:
dfs_stack.append((v, u, next_flow))
return None, None
main() | from sys import stdin
from collections import defaultdict
readline = stdin.readline
def main():
v, e = list(map(int, readline().split()))
g = defaultdict(set)
residual = [[0] * v for _ in range(v)]
source, sink = 0, v - 1
for _ in range(e):
s, t, c = list(map(int, readline().split()))
if 0 < c and s != sink and t != source:
g[s] |= {t}
g[t] |= {s}
residual[s][t] = c
while True:
route, flow = search(g, residual, source, sink)
if not route:
break
for s, t in zip(route, route[1:]):
residual[s][t] -= flow
residual[t][s] += flow
print((sum(residual[sink][i] for i in g[sink])))
def search(g, residual, source, sink):
dfs_stack = [(source, None, float('inf'))]
route = [None]
visited = set()
while dfs_stack:
u, prev, flow = dfs_stack.pop()
while route[-1] != prev:
route.pop()
route.append(u)
visited |= {u}
if u == sink:
return route[1:], flow
for v in g[u]:
if v not in visited and 0 < residual[u][v]:
dfs_stack.append((v, u, min(residual[u][v], flow)))
return [], 0
main() | p02376 |
#!/usr/bin/env python3
# Based on https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
import collections
import sys
import uuid
REC_LIMIT = 10000
class Edge(object):
def __init__(self, source, sink, capacity):
self.source = source
self.sink = sink
self.capacity = capacity
self.rev_edge = None
self.edge_id = uuid.uuid4()
def __str__(self):
return "Edge {} -> {} : {}".format(self.source,
self.sink, self.capacity)
class Network(object):
def __init__(self):
self.adj_edges = collections.defaultdict(list)
self.flow = dict()
self.used_edge = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
f_edge = Edge(source, sink, capacity)
b_edge = Edge(sink, source, 0)
f_edge.rev_edge = b_edge
b_edge.rev_edge = f_edge
self.adj_edges[source].append(f_edge)
self.adj_edges[sink].append(b_edge)
self.flow[f_edge] = 0
self.flow[b_edge] = 0
def find_path_rec(self, source, sink, path):
if source == sink:
return path
for edge in self.get_edges_from(source):
residual = edge.capacity - self.flow[edge]
if residual > 0 and not self.used_edge[edge.edge_id]:
self.used_edge[edge.edge_id] = True
result = self.find_path_rec(edge.sink, sink, path + [edge])
if result is not None:
return result
def find_path(self, *args):
self.used_edge = collections.defaultdict(bool)
return self.find_path_rec(*args)
def max_flow(self, source, sink):
while True:
path = self.find_path(source, sink, [])
if path is None:
break
flow = min(edge.capacity - self.flow[edge] for edge in path)
for edge in path:
self.flow[edge] += flow
self.flow[edge.rev_edge] -= flow
return sum(self.flow[edge] for edge in self.get_edges_from(source))
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = Network()
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.max_flow(0, v - 1)
print(mf)
if __name__ == '__main__':
main() | #!/usr/bin/env python3
# Based on ...
# https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
# http://algoogle.hadrori.jp/algorithm/ford-fulkerson.html
import collections
import sys
REC_LIMIT = 10000
INF = 10 ** 8
class Edge(object):
def __init__(self, source, sink, capacity):
self.source = source
self.sink = sink
self.capacity = capacity
self.rev_edge = None
def __str__(self):
return "Edge {} -> {} : {}".format(self.source,
self.sink, self.capacity)
class FlowNetwork(object):
def __init__(self):
self.adj_edges = collections.defaultdict(list)
self.flow = dict()
self.used_edge = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
f_edge = Edge(source, sink, capacity)
b_edge = Edge(sink, source, 0)
f_edge.rev_edge = b_edge
b_edge.rev_edge = f_edge
self.adj_edges[source].append(f_edge)
self.adj_edges[sink].append(b_edge)
self.flow[f_edge] = 0
self.flow[b_edge] = 0
def dfs(self, source, sink, flow):
if source == sink:
return flow
self.used_edge[source] = True
for edge in self.get_edges_from(source):
residual = edge.capacity - self.flow[edge]
if self.used_edge[edge.sink] or residual <= 0:
continue
d = self.dfs(edge.sink, sink, min(flow, residual))
if d > 0:
self.flow[edge] += d
self.flow[edge.rev_edge] -= d
return d
return 0
def ford_fulkerson(self, source, sink):
max_flow = 0
while True:
self.used_edge = collections.defaultdict(bool)
df = self.dfs(source, sink, INF)
if df == 0:
return max_flow
else:
max_flow += df
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = FlowNetwork()
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.ford_fulkerson(0, v - 1)
print(mf)
if __name__ == '__main__':
main() | p02376 |
from collections import defaultdict
def dfs(source, sink, flow, connect):
if source == sink:
return flow
used[source] = 1
for i, (target, cost, rev_i) in enumerate(connect[source]):
if not used[target] and cost > 0:
that_flow = dfs(target, sink, min(flow, cost), connect)
if that_flow > 0:
connect[source][i][1] -= that_flow
connect[target][rev_i][1] += that_flow
return that_flow
return 0
v_num, e_num = (int(n) for n in input().split(" "))
connect = defaultdict(list)
for _ in range(e_num):
s, t, cost = (int(n) for n in input().split(" "))
connect[s].append([t, cost, len(connect[t])])
connect[t].append([s, 0, len(connect[s]) - 1])
answer = 0
base_used = [0 for n in range(v_num)]
while True:
used = base_used.copy()
now_flow = dfs(0, v_num - 1, float("inf"), connect)
if now_flow == 0:
break
answer += now_flow
print(answer) | from collections import defaultdict
def bfs(start, end, connect, v_num, flow):
level = [-1] * v_num
level[start] = 0
queue = [start]
while queue:
v = queue.pop()
for next_v in connect[v]:
if flow[v][next_v] > 0 and level[next_v] < 0:
level[next_v] = level[v] + 1
queue.append(next_v)
return level
def dfs(here, end, connect, level, flow, minimum_f, visited):
if here == end:
return minimum_f
for next_v in connect[here]:
if not visited[here][next_v] and flow[here][next_v] > 0 and level[here] < level[next_v]:
visited[here][next_v] = 1
temp_f = dfs(next_v, end, connect, level, flow, min(flow[here][next_v], minimum_f), visited)
if temp_f:
flow[here][next_v] -= temp_f
flow[next_v][here] += temp_f
# print(flow)
return temp_f
return 0
v_num, e_num = (int(n) for n in input().split(" "))
connect = defaultdict(list)
flow = defaultdict(lambda: defaultdict(int))
for _ in range(e_num):
s, t, c = list(map(int, input().split(" ")))
connect[s].append(t)
connect[t].append(s)
flow[s][t] = c
start = 0
end = v_num - 1
answer = 0
while True:
level = bfs(start, end, connect, v_num, flow)
if level[end] < 0:
print(answer)
break
visited = defaultdict(lambda: defaultdict(int))
temp_f = dfs(start, end, connect, level, flow, float("inf"), visited)
while temp_f > 0:
answer += temp_f
temp_f = dfs(start, end, connect, level, flow, float("inf"), visited)
| p02376 |
def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0 for i in range(nvertices)] for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float('inf')
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while parents[v] != -1:
adj[parents[v]][v] -= f
adj[v][parents[v]] += f
v = parents[v]
print(ans)
def bfs(s, t, adj):
visited = [False] * len(adj)
que = [s]
parents = [-1] * len(adj)
while que:
u = que.pop(0)
visited[u] = True
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
que.append(v)
return None
main() | def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0] * nvertices for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float('inf')
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while v != 0:
u = parents[v]
adj[u][v] -= f
adj[v][u] += f
v = u
print(ans)
def bfs(s, t, adj):
nvertices = len(adj)
visited = [False] * nvertices
visited[0] = True
que = [s]
parents = [-1] * nvertices
while que:
u = que.pop(0)
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
visited[v] = True
que.append(v)
return None
main() | p02376 |
G_MAX = 40*10
N_MAX = 40
INF = float('inf')
dp = [[[INF]*(G_MAX+1) for _ in range(G_MAX+1)]
for _ in range(N_MAX+1)]
N,Ma,Mb = list(map(int, input().split()))
a,b,c = [],[],[]
for _ in range(N):
ai,bi,ci = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c.append(ci)
dp[0][0][0] = 0
from math import isinf
for i in range(N):
for ca in range(G_MAX+1):
for cb in range(G_MAX+1):
if isinf(dp[i][ca][cb]): 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 = INF
for ca in range(1,G_MAX+1):
for cb in range(1,G_MAX+1):
if ca*Mb==cb*Ma:
ans = min(ans, dp[N][ca][cb])
if isinf(ans): ans = -1
print(ans) | from math import isinf
N, Ma, Mb = list(map(int, input().split()))
a = [0]*N
b = [0]*N
c = [0]*N
for i in range(N):
a[i],b[i],c[i] = list(map(int, input().split()))
W_MAX = 40*10
dp = [[float('inf')]*(W_MAX+1) for _ in range(W_MAX+1)]
dp[0][0] = 0
for i in range(N):
for wa in reversed(list(range(W_MAX+1))):
for wb in reversed(list(range(W_MAX+1))):
if isinf(dp[wa][wb]): continue
if wa+a[i]<=W_MAX and wb+b[i]<=W_MAX:
dp[wa+a[i]][wb+b[i]] = min(dp[wa+a[i]][wb+b[i]],
dp[wa][wb]+c[i])
ans = float('inf')
for wa in range(1, W_MAX+1):
for wb in range(1, W_MAX+1):
if wa*Mb == wb*Ma:
ans = min(ans, dp[wa][wb])
if isinf(ans): ans = -1
print(ans) | p03806 |
N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 401
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
i = M - a - 1
while i >= 0:
j = M - b - 1
while j >= 0:
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
j -= 1
i -= 1
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 1 + min(sum([ a for a, b, c in G ]),
sum([ b for a, b, c in G ]) )
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
i = M - a - 1
while i >= 0:
j = M - b - 1
while j >= 0:
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
j -= 1
i -= 1
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 1 + min(sum([ a for a, b, c in G ]),
sum([ b for a, b, c in G ]) )
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
i = M - a - 1
while i >= 0:
j = M - b - 1
while j >= 0:
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
j -= 1
i -= 1
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
G = []
for i in range(N):
a, b, c = list(map(int, input().split()))
G.append( (a,b,c) )
M = 1 + min(sum([ a for a, b, c in G ]),
sum([ b for a, b, c in G ]) )
INF = 1000000000
dp = [INF] * (M * M)
dp[0] = 0
for a, b, c in G:
for i in reversed(list(range(0, M - a))):
for j in reversed(list(range(0, M - b))):
dp[(i+a)*M+(j+b)] = min(dp[(i+a)*M+(j+b)], dp[i*M+j] + c)
ans = INF
x = 1
while Ma * x < M and Mb * x < M:
ans = min(ans, dp[Ma * x * M + Mb * x])
x += 1
if ans >= INF:
ans = -1
print(ans)
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
D = [tuple(map(int, input().split())) for _ in range(N)]
def dfs(L, D, i, ta, tb, tc):
if i==len(D):
key = (ta, tb)
L[key] = min(L[key], tc) if key in L else tc
return
a, b, c = D[i]
dfs(L, D, i+1, ta , tb , tc )
dfs(L, D, i+1, ta+a, tb+b, tc+c)
L1, L2 = {}, {}
dfs(L1, D[:N//2], 0, 0, 0, 0)
dfs(L2, D[N//2:], 0, 0, 0, 0)
ans = 10**9
for m in range(1,401):
ma = Ma * m
mb = Mb * m
if ma>400 or mb>400: break
for key1 in L1:
ta1, tb1 = key1
ta2 = ma - ta1
tb2 = mb - tb1
key2 = (ta2, tb2)
if key2 in L2: ans = min(ans, L1[key1]+L2[key2])
print((ans if ans!=10**9 else -1)) | N, Ma, Mb = list(map(int, input().split()))
D = [tuple(map(int, input().split())) for _ in range(N)]
def listup(L, D):
for a, b, c in D:
for (ka, kb), kc in list(L.copy().items()):
key = (ka+a, kb+b)
L[key] = min(L[key], kc+c) if key in L else kc+c
L1 = {(0,0):0}
L2 = {(0,0):0}
listup(L1, D[:N//2])
listup(L2, D[N//2:])
ans = 10**9
for m in range(1,401):
ma = Ma * m
mb = Mb * m
if ma>400 or mb>400: break
for key1 in L1:
ta1, tb1 = key1
ta2 = ma - ta1
tb2 = mb - tb1
key2 = (ta2, tb2)
if key2 in L2: ans = min(ans, L1[key1]+L2[key2])
print((ans if ans!=10**9 else -1)) | p03806 |
INF = 10**18
def solve(N, Ma, Mb, sol):
if N % 2 == 1:
sol.append((0, 0, 0))
N += 1
M = N // 2
sol1 = sol[:M]
sol2 = sol[M:]
S1 = []
S2 = []
for i in range(2**M):
A1, B1, C1 = 0, 0, 0
A2, B2, C2 = 0, 0, 0
for j in range(M):
if (i >> j) & 1:
a1, b1, c1 = sol1[j]
a2, b2, c2 = sol2[j]
A1 += a1
B1 += b1
C1 += c1
A2 += a2
B2 += b2
C2 += c2
S1.append((A1, B1, C1))
S2.append((A2, B2, C2))
D = dict()
S2.sort(key=lambda x: x[2], reverse=True)
res = INF
for i in range(2**M):
a, b, c = S2[i]
x = Mb * a - Ma * b
if x == 0 and c > 0:
res = min(res, c)
if not x in D or c > 0:
D[x] = c
for i in range(2**M):
a, b, c = S1[i]
x = Ma * b - Mb * a
if x == 0 and c > 0:
res = min(res, c)
if x in D and D[x] + c > 0:
res = min(res, D[x] + c)
return res
N, Ma, Mb = list(map(int, input().split()))
sol = [tuple(map(int, input().split())) for _ in range(N)]
res = solve(N, Ma, Mb, sol)
print((res if res != INF else -1)) | INF = 10**18
def solve(N, Ma, Mb, sol):
if N % 2 == 1:
sol.append((0, 0, 0))
N += 1
M = N // 2
sol1 = sol[:M]
sol2 = sol[M:]
S1 = []
D = dict()
res = INF
for i in range(2**M):
A1, B1, C1 = 0, 0, 0
A2, B2, C2 = 0, 0, 0
for j in range(M):
if (i >> j) & 1:
a1, b1, c1 = sol1[j]
a2, b2, c2 = sol2[j]
A1 += a1
B1 += b1
C1 += c1
A2 += a2
B2 += b2
C2 += c2
S1.append((A1, B1, C1))
x = Mb * A2 - Ma * B2
if x == 0 and C2 > 0:
res = min(res, C2)
if not x in D or 0 < C2 < D[x]:
D[x] = C2
for i in range(2**M):
a, b, c = S1[i]
x = Ma * b - Mb * a
if x == 0 and c > 0:
res = min(res, c)
if x in D and D[x] + c > 0:
res = min(res, D[x] + c)
return res
N, Ma, Mb = list(map(int, input().split()))
sol = [tuple(map(int, input().split())) for _ in range(N)]
res = solve(N, Ma, Mb, sol)
print((res if res != INF else -1)) | p03806 |
import math
nmax = 40
abmax = 10
INF = 10000
#入力
N, Ma, Mb = list(map(int, input().split()))
medichine = []
for i in range(N):
Lst = [int(x) for x in input().split()]
medichine.append(Lst)
dp = {}
#dp初期化
for i in range(N+1):
for ca in range(nmax*abmax+1):
for cb in range(nmax*abmax+1):
dp[i,ca,cb] = INF
dp[0,0,0] = 0
for i in range(N):
for ca in range(nmax*abmax+1):
for cb in range(nmax*abmax+1):
if dp[i,ca,cb] != INF:
dp[i+1,ca,cb] = min(dp[i+1,ca,cb],dp[i,ca,cb])
dp[i+1,ca+medichine[i][0],cb+medichine[i][1]] = min(dp[i+1,ca+medichine[i][0],cb+medichine[i][1]], dp[i,ca,cb]+medichine[i][2])
ans = INF
for ca in range(1,nmax*abmax+1):
for cb in range(1,nmax*abmax+1):
if ca*Mb == cb*Ma:
ans = min(ans,dp[N,ca,cb])
if ans == INF:
ans = -1
print(ans) | import collections
import copy
INF = 10000
#入力
N, Ma, Mb = list(map(int, input().split()))
medichine = [tuple(map(int, input().split())) for _ in range(N)]
dp = {}
#dp初期化
dp = collections.defaultdict(lambda:INF)
dp[0,0] = 0
for a, b, c in medichine:
dp_ = copy.copy(dp)
for ca,cb in list(dp.keys()):
dp_[ca+a, cb+b] = min(dp_[ca+a, cb+b], dp[ca,cb]+c)
dp = dp_
ans = INF
for ca,cb in list(dp.keys()):
if ca == cb == 0: continue
if ca*Mb == cb*Ma:
ans = min(ans, dp[ca,cb])
print((-1 if ans == INF else ans)) | p03806 |
N, Ma, Mb = list(map(int, input().split()))
A, B, C = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
A.append(ai)
B.append(bi)
C.append(ci)
INF = float('inf')
dp = [[[INF]*401 for i in range(401)] for j in range(N+1)]
dp[0][0][0] = 0
for i in range(1, N+1):
for a in range(1, 401):
if A[i-1] > a:
continue
for b in range(1, 401):
if A[i-1] <= a and B[i-1] <= b:
dp[i][a][b] = min(dp[i-1][a][b], dp[i-1][a-A[i-1]][b-B[i-1]] + C[i-1])
ans = INF
for i in range(1, 401):
target_a = Ma * i
target_b = Mb * i
if target_a > 400 or target_b > 400:
break
ans = min(ans, dp[N][target_a-1][target_b-1])
print((ans if ans != INF else -1))
| N, Ma, Mb = list(map(int, input().split()))
A, B, C = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
A.append(ai)
B.append(bi)
C.append(ci)
INF = float('inf')
dp = [[[INF]*401 for i in range(401)] for j in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for a in range(401):
for b in range(401):
if dp[i][a][b] == INF:
continue
dp[i+1][a][b] = min(dp[i+1][a][b], dp[i][a][b])
if a + A[i] <= 400 and b + B[i] <= 400:
dp[i+1][a+A[i]][b+B[i]] = min(dp[i+1][a+A[i]][b+B[i]], dp[i][a][b]+C[i])
ans = INF
for i in range(1, 401):
target_a = Ma * i
target_b = Mb * i
if target_a > 400 or target_b > 400:
break
ans = min(ans, dp[N][target_a][target_b])
print((ans if ans != INF else -1))
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
Items = [list(map(int, input().split())) for i in range(N)]
# dp[i][a][b] := i個目の薬品までで薬品Aがaグラム、薬品Bがbグラムの混合液を作るために必要な最小予算
dp = [[[float('inf')] * 401 for j in range(401)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
ai, bi, ci = Items[i]
for a in range(401):
for b in range(401):
if a + ai <= 400 and b + bi <= 400:
dp[i + 1][a + ai][b + bi] = min(dp[i][a][b] + ci, dp[i + 1][a + ai][b + bi])
dp[i + 1][a][b] = min(dp[i][a][b], dp[i + 1][a][b])
ans = float('inf')
i = 1
while Ma * i <= 400 and Mb * i <= 400:
ans = min(ans, dp[N][Ma * i][Mb * i])
i += 1
print((ans if ans != float('inf') else -1))
| N, Ma, Mb = list(map(int, input().split()))
Items = [list(map(int, input().split())) for i in range(N)]
# dp[i][a][b] := i個目の薬品までで薬品Aがaグラム、薬品Bがbグラムの混合液を作るために必要な最小予算
dp = [[[float('inf')] * 401 for j in range(401)] for i in range(N + 1)]
dp[0][0][0] = 0
for i in range(1, N + 1):
ai, bi, ci = Items[i - 1]
for a in range(401):
for b in range(401):
if a - ai >= 0 and b - bi >= 0:
dp[i][a][b] = min(dp[i][a][b], dp[i - 1][a][b], dp[i - 1][a - ai][b - bi] + ci)
else:
dp[i][a][b] = min(dp[i][a][b], dp[i - 1][a][b])
ans = float('inf')
i = 1
while Ma * i <= 400 and Mb * i <= 400:
ans = min(ans, dp[N][Ma * i][Mb * i])
i += 1
print((ans if ans != float('inf') else -1))
| p03806 |
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
n,ma,mb = inm()
a = []
b = []
c = []
for i in range(n):
aa,bb,cc = inm()
a.append(aa)
b.append(bb)
c.append(cc)
dp = [[BIG]*(100*n+1) for i in range(100*n+1)]
dp[0][0] = 0
for t in range(n):
dp2 = [[BIG]*(100*n+1) for i in range(100*n+1)]
for i in range(10*t+1):
for j in range(10*t+1):
if dp[i][j]<BIG:
dp2[i][j] = min(dp2[i][j],dp[i][j])
dp2[i+a[t]][j+b[t]] = min( \
dp2[i+a[t]][j+b[t]], dp[i][j]+c[t])
dp = dp2
mn = BIG
for i in range(1,5000):
if i*max(ma,mb)>n*100:
break
#ddprint(f"i {i} n {n} ma {ma} mb {mb} ima {i*ma}")
mn = min(mn, dp[i*ma][i*mb])
print((-1 if mn==BIG else mn))
| from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
ins = lambda : input().strip()
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
n,ma,mb = inm()
a = []
b = []
c = []
for i in range(n):
aa,bb,cc = inm()
a.append(aa)
b.append(bb)
c.append(cc)
dp = [[BIG]*(10+1) for i in range(10+1)]
dp[0][0] = 0
for t in range(n):
dp2 = [[BIG]*(10*(t+1)+1) for i in range(10*(t+1)+1)]
for i in range(10*t+1):
for j in range(10*t+1):
if dp[i][j]<BIG:
dp2[i][j] = min(dp2[i][j],dp[i][j])
dp2[i+a[t]][j+b[t]] = min( \
dp2[i+a[t]][j+b[t]], dp[i][j]+c[t])
dp = dp2
mn = BIG
for i in range(1,5000):
if i*max(ma,mb)>n*10:
break
#ddprint(f"i {i} n {n} ma {ma} mb {mb} ima {i*ma}")
mn = min(mn, dp[i*ma][i*mb])
print((-1 if mn==BIG else mn))
| p03806 |
def main():
INF = 10 ** 20
n, ma, mb = list(map(int, input().split()))
dp = [[INF] * 401 for _ in range(401)]
dp[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for i in range(400 - a, -1, -1):
for j in range(400 - b, -1, -1):
dp[i + a][j + b] = min(dp[i + a][j + b], dp[i][j] + c)
ans = INF
for i in range(1, 400):
if ma * i > 400 or mb * i > 400:
break
ans = min(ans, dp[ma * i][mb * i])
if ans >= INF:
print((-1))
else:
print(ans)
main() | def main():
INF = 10 ** 5
n, ma, mb = list(map(int, input().split()))
dp = [[INF] * 401 for _ in range(401)]
dp[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for i in range(400 - a, -1, -1):
dpi = dp[i]
dpia = dp[i + a]
for j in range(400 - b, -1, -1):
if dpia[j + b] > dpi[j] + c:
dpia[j + b] = dpi[j] + c
ans = INF
for i in range(1, 400):
if ma * i > 400 or mb * i > 400:
break
ans = min(ans, dp[ma * i][mb * i])
if ans >= INF:
print((-1))
else:
print(ans)
main() | p03806 |
N,Ma,Mb=list(map(int, input().strip().split()))
abc=[list(map(int, input().strip().split())) for i in range(N)]
maxW=N*10
dp=[[[float("inf")]*(maxW+1) for _ in range(maxW+1)]for __ in range(N+1)]
dp[0][0][0]=0
for i in range(N):
a,b,c=abc[i]
for ai in range(maxW):
for bi in range(maxW):
if dp[i][ai][bi]==float("inf"):continue
dp[i+1][ai][bi] = min(dp[i+1][ai][bi],dp[i][ai][bi])
dp[i+1][ai+a][bi+b] = min(dp[i][ai][bi]+c,dp[i+1][ai+a][bi+b])
cost=float("inf")
Mad=Ma
Mbd=Mb
while Ma<=maxW and Mb <=maxW:
cost=min(dp[-1][Ma][Mb],cost)
Ma+=Mad
Mb+=Mbd
print((-1 if cost==float("inf") else cost)) | N,Ma,Mb=list(map(int, input().strip().split()))
abc=[list(map(int, input().strip().split())) for i in range(N)]
maxW=N*10
dp=[{} for __ in range(N+1)]
dp[0][(0,0)]=0
for i in range(N):
a,b,c=abc[i]
for k,v in list(dp[i].items()):
dp[i+1][k]=min(dp[i][k], dp[i+1][k]if k in dp[i+1] else float("inf"))
dp[i+1][k[0]+a,k[1]+b]=min(dp[i][k]+c, dp[i+1][k[0]+a,k[1]+b] if (k[0]+a,k[1]+b)in dp[i+1] else float("inf"))
cost=float("inf")
Mad=Ma
Mbd=Mb
while Ma<=maxW and Mb <=maxW:
if (Ma,Mb) in dp[-1]:
cost=min(dp[-1][Ma,Mb],cost)
Ma+=Mad
Mb+=Mbd
print((-1 if cost==float("inf") else cost)) | p03806 |
N,Ma,Mb=list(map(int,input().split()))
medic=[tuple(map(int,input().split())) for _ in range(N)]
from collections import defaultdict
inf = float('inf')
dp=defaultdict(lambda :inf)
dp[(0,0)]=0
for n in range(N):
dpc=dp.copy()
a,b,c=medic[n]
for d,cost in list(dpc.items()):
da,db=d
dp[(da+a,db+b)]=min(dp[(da+a,db+b)],c+cost)
ans=inf
nowa,nowb=Ma,Mb
while nowa<=400 and nowb<=400:
ans=min(ans,dp[nowa,nowb])
nowa+=Ma
nowb+=Mb
if ans>4000:ans=-1
print(ans) | N,Ma,Mb=list(map(int,input().split()))
medic=[tuple(map(int,input().split())) for i in range(N)]
from collections import defaultdict
dp=defaultdict(lambda : float('inf'))
dp[(0,0)]=0
for a,b,c in medic:
dpc=dp.copy()
for k,v in list(dpc.items()):
x,y=k
dp[(x+a,y+b)]=min(dp[(x+a,y+b)],v+c)
ans=10**10
for i in range(1,1+N):
ans=min(ans,dp[(Ma*i,Mb*i)])
if ans>10**9:
print((-1))
else:
print(ans) | p03806 |
N, Ma, Mb = list(map(int,input().split()))
a=[0]*N
b=[0]*N
c=[0]*N
for i in range(N):
a[i], b[i], c[i] = list(map(int,input().split()))
dp = [[[4001 for i in range(411)] for j in range(411)] for l in range(N+1)]
dp[0][0][0] = 0
for i in range(1,N+1):
for j in range(400):
for k in range(400):
dp[i][j+a[i-1]][k+b[i-1]] = min(dp[i-1][j][k] + c[i-1],dp[i-1][j+a[i-1]][k+b[i-1]])
dp[i][j][k] = min(dp[i - 1][j][k], dp[i][j][k])
s = min(400//Ma,400//Mb)
min = 4001
for i in range(1,s+1):
x = dp[N][i*Ma][i*Mb]
if x>0 and min > x:
min = x
if min != 4001:
print(min)
else:
print((-1))
| N, Ma, Mb = list(map(int,input().split()))
a=[0]*N
b=[0]*N
c=[0]*N
for i in range(N):
a[i], b[i], c[i] = list(map(int,input().split()))
dp = [[[4001 for i in range(411)] for j in range(411)] for l in range(N+1)]
dp[0][0][0] = 0
for i in range(1,N+1):
for j in range(400):
for k in range(400):
if dp[i-1][j][k] == 4001:
continue
dp[i][j+a[i-1]][k+b[i-1]] = min(dp[i-1][j][k] + c[i-1],dp[i-1][j+a[i-1]][k+b[i-1]])
dp[i][j][k] = min(dp[i - 1][j][k], dp[i][j][k])
s = min(400//Ma,400//Mb)
min = 4001
for i in range(1,s+1):
x = dp[N][i*Ma][i*Mb]
if x>0 and min > x:
min = x
if min != 4001:
print(min)
else:
print((-1))
| p03806 |
n, ma, mb = list(map(int, input().split()))
N = 403
memo = [[10**18]*(N+20) for i in range(N+20)]
memo[0][0] = 0
for t in range(n):
a, b, c = list(map(int, input().split()))
for i in range(N, -1, -1):
for j in range(N, -1, -1):
memo[i+a][j+b] = min(memo[i+a][j+b], memo[i][j] + c)
ans = 10**18
a = ma; b = mb
while a < N and b < N:
ans = min(ans, memo[a][b])
a += ma; b += mb
print(-1 if ans > 50000 else ans) | from heapq import heappush, heappop
n, ma, mb = list(map(int, input().split()))
dp = {(0, 0): 0}
INF = 10**18
for i in range(n):
a, b, c = list(map(int, input().split()))
for x, y in sorted(dp.keys())[::-1]:
dp[x+a, y+b] = min(dp.get((x+a, y+b), INF), dp[x, y] + c)
ans = INF
for x, y in dp:
if x*mb == y*ma > 0:
ans = min(ans, dp[x, y])
print(-1 if ans==INF else ans) | p03806 |
#!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, M_a: int, M_b: int, a: "List[int]", b: "List[int]", c: "List[int]"):
t = [[float("inf")] * (10 * N + 1) for _ in range(10 * N + 1)]
t[0][0] = 0
for ai, bi, ci in zip(a, b, c):
for ta in reversed(list(range(ai, len(t)))):
for tb in reversed(list(range(bi, len(t[0])))):
t[ta][tb] = min(t[ta][tb], t[ta - ai][tb - bi] + ci)
ans = min(
t[k * M_a][k * M_b]
for k in range(1, min((len(t) - 1) // M_a, (len(t[0]) - 1) // M_b) + 1)
)
print((-1 if ans == float("inf") else ans))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M_a = int(next(tokens)) # type: int
M_b = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
c = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(N, M_a, M_b, a, b, c)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, M_a: int, M_b: int, a: "List[int]", b: "List[int]", c: "List[int]"):
inf = 100000
t = [[inf] * (10 * N + 1) for _ in range(10 * N + 1)]
t[0][0] = 0
for ai, bi, ci in zip(a, b, c):
for ta in reversed(list(range(ai, len(t)))):
for tb in reversed(list(range(bi, len(t[0])))):
t[ta][tb] = min(t[ta][tb], t[ta - ai][tb - bi] + ci)
ans = min(
t[k * M_a][k * M_b]
for k in range(1, min((len(t) - 1) // M_a, (len(t[0]) - 1) // M_b) + 1)
)
print((-1 if ans >= inf else ans))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M_a = int(next(tokens)) # type: int
M_b = int(next(tokens)) # type: int
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
c = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(N, M_a, M_b, a, b, c)
if __name__ == '__main__':
main()
| p03806 |
#!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
N, M_a, M_b = [int(x) for x in input().split()]
inf = 100000
t = [[inf] * (10 * N + 1) for _ in range(10 * N + 1)]
t[0][0] = 0
for _ in range(N):
ai, bi, ci = [int(x) for x in input().split()]
for ta in reversed(list(range(ai, len(t)))):
for tb in reversed(list(range(bi, len(t[0])))):
t[ta][tb] = min(t[ta][tb], t[ta - ai][tb - bi] + ci)
ans = min(
t[k * M_a][k * M_b]
for k in range(1, min((len(t) - 1) // M_a, (len(t[0]) - 1) // M_b) + 1)
)
print((-1 if ans >= inf else ans))
| #!/usr/bin/env python3
def solve():
N, M_a, M_b = [int(x) for x in input().split()]
inf = 100000
t = [[inf] * (10 * N + 1) for _ in range(10 * N + 1)]
t[0][0] = 0
for _ in range(N):
ai, bi, ci = [int(x) for x in input().split()]
for ta in reversed(list(range(ai, len(t)))):
for tb in reversed(list(range(bi, len(t[0])))):
t[ta][tb] = min(t[ta][tb], t[ta - ai][tb - bi] + ci)
ans = min(
t[k * M_a][k * M_b]
for k in range(1, min((len(t) - 1) // M_a, (len(t[0]) - 1) // M_b) + 1)
)
print((-1 if ans >= inf else ans))
solve()
| p03806 |
import sys
input = sys.stdin.buffer.readline
N, Ma, Mb = list(map(int, input().split()))
ABC = [list(map(int, input().split())) for _ in range(N)]
INF = 10 ** 15
dp = [[INF for j in range(401)] for i in range(401)]
dp[0][0] = 0
for a, b, c in ABC:
for i in range(400, -1, -1):
for j in range(400, -1, -1):
if dp[i][j] != INF:
dp[i + a][j + b] = min(dp[i + a][j + b], dp[i][j] + c)
answer = INF
for i in range(1, 401):
for j in range(1, 401):
if dp[i][j] != INF and i / j == Ma / Mb:
answer = min(answer, dp[i][j])
print((answer if answer != INF else -1)) | import sys
input = sys.stdin.buffer.readline
N, Ma, Mb = list(map(int, input().split()))
ABC = [list(map(int, input().split())) for _ in range(N)]
sumA = sum([ABC[i][0] for i in range(N)])
sumB = sum([ABC[i][1] for i in range(N)])
INF = 10 ** 15
dp = [[INF for j in range(sumB + 1)] for i in range(sumA + 1)]
dp[0][0] = 0
for a, b, c in ABC:
for i in range(sumA, -1, -1):
for j in range(sumB, -1, -1):
if dp[i][j] != INF:
dp[i + a][j + b] = min(dp[i + a][j + b], dp[i][j] + c)
answer = INF
for i in range(1, sumA + 1):
for j in range(1, sumB + 1):
if dp[i][j] != INF and i / j == Ma / Mb:
answer = min(answer, dp[i][j])
print((answer if answer != INF else -1)) | p03806 |
import itertools
N,MA,MB = list(map(int,input().split()))
arr = []
for i in range(N):
l = list(map(int,input().split()))
arr.append(l)
dp = [ [ [50000 for k in range(401)] for j in range(401)] for i in range(N+1) ]
dp[0][0][0] = 0
for i,a,b in itertools.product(list(range(1,N+1)),list(range(401)),list(range(401))):
A = arr[i-1][0]
B = arr[i-1][1]
C = arr[i-1][2]
if A <= a and B <= b:
dp[i][a][b] = min(dp[i][a][b],dp[i-1][a-A][b-B] + C)
else:
dp[i][a][b] = dp[i-1][a][b]
ans = 50000
for i,a,b in itertools.product(list(range(N+1)),list(range(401)),list(range(401))):
if a * MB == b ** MA and a != 0 and b != 0:
ans = min(ans,dp[i][a][b])
if ans == 50000:
print((-1))
else:
print((int(ans))) | import itertools
N,MA,MB = list(map(int,input().split()))
arr = []
for i in range(N):
l = list(map(int,input().split()))
arr.append(l)
dp = [ [ [50000 for k in range(401)] for j in range(401)] for i in range(N+1) ]
dp[0][0][0] = 0
ans = 50000
for i,a,b in itertools.product(list(range(1,N+1)),list(range(401)),list(range(401))):
A = arr[i-1][0]
B = arr[i-1][1]
C = arr[i-1][2]
if A <= a and B <= b and dp[i-1][a-A][b-B] != 50000:
dp[i][a][b] = min(dp[i-1][a][b],dp[i-1][a-A][b-B] + C)
else:
dp[i][a][b] = dp[i-1][a][b]
for a,b in itertools.product(list(range(401)),list(range(401))):
if a * MB == b * MA and a != 0 and b != 0:
ans = min(ans,dp[-1][a][b])
if ans == 50000:
print((-1))
else:
print((int(ans))) | p03806 |
def solve():
N, Ma, Mb = list(map(int, input().split()))
a, b, c = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c.append(ci)
alim = sum(a)
blim = sum(b)
inf = 40 * 100 + 1
dp = [[inf]*(blim + 1) for i in range(alim + 1)]
dp[0][0] = 0
for i in range(N):
for u in range(alim, a[i] - 1, -1):
for v in range(blim, b[i] - 1, -1):
dp[u][v] = min(dp[u][v], dp[u - a[i]][v - b[i]] + c[i])
ans = inf
for u in range(1, alim + 1):
for v in range(1, blim + 1):
if u * Mb == v * Ma:
ans = min(ans, dp[u][v])
if ans < inf:
print(ans)
else:
print((-1))
if __name__ == '__main__':
solve() |
def solve():
N, Ma, Mb = list(map(int, input().split()))
a, b, c = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c.append(ci)
nvals = 99 * N * 2 + 1
inf = 40 * 100 + 1
dp = [[inf] * nvals for i in range(N)]
for i in range(N):
v = Mb * a[i] - Ma * b[i]
if i == 0:
dp[i][v] = c[i]
continue
for j in range(-99 * N, 99 * N + 1):
if -99 * N <= j - v <= 99 * N:
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v] + c[i])
dp[i][v] = min(dp[i][v], c[i])
ans = dp[N - 1][0]
if ans < inf:
print(ans)
else:
print((-1))
if __name__ == '__main__':
solve() | p03806 |
def solve():
N, Ma, Mb = list(map(int, input().split()))
a, b, c = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c.append(ci)
nvals = 99 * N * 2 + 1
inf = 40 * 100 + 1
dp = [[inf] * nvals for i in range(N)]
for i in range(N):
v = Mb * a[i] - Ma * b[i]
if i == 0:
dp[i][v] = c[i]
continue
for j in range(-99 * N, 99 * N + 1):
if -99 * N <= j - v <= 99 * N:
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v] + c[i])
dp[i][v] = min(dp[i][v], c[i])
ans = dp[N - 1][0]
if ans < inf:
print(ans)
else:
print((-1))
if __name__ == '__main__':
solve() |
def solve():
N, Ma, Mb = list(map(int, input().split()))
a, b, c = [], [], []
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c.append(ci)
nvals = 99 * N * 2 + 1
inf = 40 * 100 + 1
dp = [inf] * nvals
for i in range(N):
v = Mb * a[i] - Ma * b[i]
if i == 0:
dp[v] = c[i]
continue
if v > 0:
for j in range(99 * N, -99 * N + v - 1, -1):
dp[j] = min(dp[j], dp[j - v] + c[i])
else:
for j in range(-99 * N, 99 * N + v + 1):
dp[j] = min(dp[j], dp[j - v] + c[i])
dp[v] = min(dp[v], c[i])
ans = dp[0]
if ans < inf:
print(ans)
else:
print((-1))
if __name__ == '__main__':
solve() | p03806 |
import copy
N, Ma, Mb = list(map(int, input().split()))
ABC = [tuple(map(int, input().split())) for _ in range(N)]
INF, W = 10 ** 10, 10 * 10 * N
dp = [[INF] * (2 * W + 1)]
for a, b, c in ABC:
dp.append(copy.deepcopy(dp[-1]))
df = a * Mb - b * Ma
dp[-1][df] = min(c, dp[-1][df])
for d in range(-W, W + 1):
dp[-1][df + d] = min(c + dp[-2][d], dp[-1][df + d])
print(("-1" if dp[N][0] == INF else dp[N][0]))
| import copy
N, Ma, Mb = list(map(int, input().split()))
ABC = [tuple(map(int, input().split())) for _ in range(N)]
INF, W = 10000, 10 * max(Ma, Mb) * N
dp = [[INF] * (2 * W + 1)]
for a, b, c in ABC:
dp.append(copy.deepcopy(dp[-1]))
df = a * Mb - b * Ma
dp[-1][df] = min(dp[-1][df], c)
for d in range(-W, W + 1):
dp[-1][df + d] = min(dp[-1][df + d], c + dp[-2][d])
print(("-1" if dp[N][0] == INF else dp[N][0]))
| p03806 |
import sys
inf = float('inf')
n, ma, mb = list(map(int, input().split()))
t = [[inf] * 401 for _ in range(401)]
for _ in range(n):
a, b, c = list(map(int, input().split()))
for aa in range(400, 0, -1):
for bb in range(400, 0, -1):
if t[aa][bb] == inf:
continue
if t[a + aa][b + bb] > c + t[aa][bb]:
t[a + aa][b + bb] = c + t[aa][bb]
if t[a][b] > c:
t[a][b] = c
result = inf
for a in range(400, 0, -1):
for b in range(400, 0, -1):
if a * mb == b * ma and t[a][b] < result:
result = t[a][b]
if result == inf:
print((-1))
else:
print(result)
| import sys
inf = float('inf')
n, ma, mb = list(map(int, input().split()))
t = [[inf] * 401 for _ in range(401)]
t[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for aa in range(400, -1, -1):
for bb in range(400, -1, -1):
if t[aa][bb] == inf:
continue
if t[a + aa][b + bb] > c + t[aa][bb]:
t[a + aa][b + bb] = c + t[aa][bb]
result = inf
for a in range(400, 0, -1):
for b in range(400, 0, -1):
if a * mb == b * ma and t[a][b] < result:
result = t[a][b]
if result == inf:
print((-1))
else:
print(result)
| p03806 |
nmax, abmax, inf = 40, 10, 1000000
a, b, c = [0] * nmax, [0] * nmax, [0] * nmax
dp = [[[0] * (nmax * abmax + 1) for _ in range(nmax * abmax + 1)] for _ in range(nmax + 1)]
n, ma, mb = list(map(int, input().split()))
for i in range(n):
x, y, z = list(map(int, input().split()))
a[i], b[i], c[i] = x, y, z
for i in range(n + 1):
for ca in range(nmax * abmax + 1):
for cb in range(nmax * abmax + 1):
dp[i][ca][cb] = inf
dp[0][0][0] = 0
for i in range(n):
for ca in range(0, 401):
for cb in range(0, 401):
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 + a[i]][cb + b[i]] = min(dp[i + 1][ca + a[i]][cb + b[i]], dp[i][ca][cb] + c[i])
ans = inf
for ca in range(1, 401):
for cb in range(1, 401):
if ca * mb == cb * ma:
ans = min(ans, dp[n][ca][cb])
if ans == inf:
ans = -1
print(ans)
| nmax, abmax, inf = 40, 10, 1000000
dp = [[[inf] * (nmax * abmax + 1) for _ in range(nmax * abmax + 1)] for _ in range(nmax + 1)]
n, ma, mb = list(map(int, input().split()))
dp[0][0][0] = 0
for i in range(n):
a, b, c = list(map(int, input().split()))
dpi = dp[i]
dpi1 = dp[i + 1]
for ca in range(0, 401):
for cb in range(0, 401):
if dpi[ca][cb] == inf:
continue
dpi1[ca][cb] = min(dpi1[ca][cb], dpi[ca][cb])
dpi1[ca + a][cb + b] = min(dpi1[ca + a][cb + b], dpi[ca][cb] + c)
ans = inf
dpn = dp[n]
for ca in range(1, 401):
for cb in range(1, 401):
if ca * mb == cb * ma:
ans = min(ans, dpn[ca][cb])
if ans == inf:
ans = -1
print(ans)
| p03806 |
nmax, abmax, inf = 40, 10, 1000000
dp = [[[inf] * (nmax * abmax + 1) for _ in range(nmax * abmax + 1)] for _ in range(nmax + 1)]
n, ma, mb = list(map(int, input().split()))
dp[0][0][0] = 0
for i in range(n):
a, b, c = list(map(int, input().split()))
dpi = dp[i]
dpi1 = dp[i + 1]
for ca in range(0, 401):
for cb in range(0, 401):
if dpi[ca][cb] == inf:
continue
dpi1[ca][cb] = min(dpi1[ca][cb], dpi[ca][cb])
dpi1[ca + a][cb + b] = min(dpi1[ca + a][cb + b], dpi[ca][cb] + c)
ans = inf
dpn = dp[n]
for ca in range(1, 401):
for cb in range(1, 401):
if ca * mb == cb * ma:
ans = min(ans, dpn[ca][cb])
if ans == inf:
ans = -1
print(ans)
| INF = float('inf')
n, ma, mb = list(map(int, input().split()))
t = [[INF] * 401 for _ in range(401)]
t[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for aa in range(400, -1, -1):
for bb in range(400, -1, -1):
if t[aa][bb] == INF:
continue
if t[a + aa][b + bb] > t[aa][bb] + c:
t[a + aa][b + bb] = t[aa][bb] + c
result = INF
for a in range(400, 0, -1):
for b in range(400, 0, -1):
if a * mb == b * ma and t[a][b] < result:
result = t[a][b]
if result == INF:
result = -1
print(result)
| p03806 |
INF = float('inf')
n, ma, mb = list(map(int, input().split()))
t = [[INF] * 401 for _ in range(401)]
t[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for aa in range(400, -1, -1):
for bb in range(400, -1, -1):
if t[aa][bb] == INF:
continue
if t[a + aa][b + bb] > t[aa][bb] + c:
t[a + aa][b + bb] = t[aa][bb] + c
result = INF
for a in range(400, 0, -1):
for b in range(400, 0, -1):
if a * mb == b * ma and t[a][b] < result:
result = t[a][b]
if result == INF:
result = -1
print(result)
| INF = float('inf')
MAXAB = 10
n, ma, mb = list(map(int, input().split()))
t = [[INF] * (n * MAXAB + 1) for _ in range(n * MAXAB + 1)]
t[0][0] = 0
for _ in range(n):
a, b, c = list(map(int, input().split()))
for aa in range(n * MAXAB, -1, -1):
for bb in range(n * MAXAB, -1, -1):
if t[aa][bb] == INF:
continue
if t[a + aa][b + bb] > t[aa][bb] + c:
t[a + aa][b + bb] = t[aa][bb] + c
result = INF
for a in range(1, n * MAXAB + 1):
for b in range(1, n * MAXAB + 1):
if a * mb == b * ma and result > t[a][b]:
result = t[a][b]
if result == INF:
result = -1
print(result)
| p03806 |
n,ma,mb=list(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**18 for i in range(401)]for j in range(401)]
dp[0][0]=0
q=[[0,0]]
for a,b,c in abc:
l=[]
for i,j in q:
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=l
ans=1145141919
i=1
while ma*i<401 and mb*i<401:
ans=min(ans,dp[ma*i][mb*i])
i+=1
if ans==1145141919:
print((-1))
else:
print(ans)
| n,ma,mb=list(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**18 for i in range(401)]for j in range(401)]
dp[0][0]=0
p,q=0,0
for a,b,c in abc:
for j in reversed(list(range(q+1))):
for i in range(p+1):
if dp[i][j]==10**18:
continue
else:
dp[i+a][j+b]=min(dp[i+a][j+b],dp[i][j]+c)
p+=a
q+=b
ans=1145141919
i=1
while ma*i<401 and mb*i<401:
ans=min(ans,dp[ma*i][mb*i])
i+=1
if ans==1145141919:
print((-1))
else:
print(ans)
| p03806 |
#!/usr/bin/env python3
from copy import deepcopy
ABMAX = 400
HUGE = 10 ** 12
def main():
n, ma, mb = list(map(int, input().split()))
sold = []
for i in range(n):
a, b, c = list(map(int, input().split()))
sold.append((a, b, c))
mincost = dp(sold, n)
print((find_mincost(mincost, ma, mb)))
def find_mincost(mincost, ma, mb):
for mult in range(1, ABMAX):
if ma * mult > ABMAX:
break
if mb * mult > ABMAX:
break
if mincost[ma * mult][mb * mult] < HUGE:
return mincost[ma * mult][mb * mult]
return -1
def dp(sold, n):
# mincost[a][b]: Minimum cost of achieving a, b
mincost = [[HUGE for b in range(ABMAX + 1)] for a in range(ABMAX + 1)]
mincost[0][0] = 0
for a, b, c in sold:
mincost = update(mincost, a, b, c)
return mincost
def update(prevcost, a, b, c):
mincost = deepcopy(prevcost)
for ia in range(ABMAX + 1): # 配る
for ib in range(ABMAX + 1):
na = ia + a
nb = ib + b
if na <= ABMAX and nb <= ABMAX:
mincost[na][nb] = min(mincost[na][nb], prevcost[ia][ib] + c)
return mincost
main()
| #!/usr/bin/env python3
from copy import deepcopy
ABMAX = 400
HUGE = 10 ** 12
def main():
n, ma, mb = list(map(int, input().split()))
sold = []
for i in range(n):
a, b, c = list(map(int, input().split()))
sold.append((a, b, c))
mincost = dp(sold, n)
print((find_mincost(mincost, ma, mb)))
def find_mincost(mincost, ma, mb):
res = HUGE
for mult in range(1, ABMAX):
if ma * mult > ABMAX:
break
if mb * mult > ABMAX:
break
res = min(res, mincost[ma * mult][mb * mult])
return -1 if res == HUGE else res
def dp(sold, n):
# mincost[a][b]: Minimum cost of achieving a, b
mincost = [[HUGE for b in range(ABMAX + 1)] for a in range(ABMAX + 1)]
mincost[0][0] = 0
for a, b, c in sold:
mincost = update(mincost, a, b, c)
return mincost
def update(prevcost, a, b, c):
mincost = deepcopy(prevcost)
for ia in range(ABMAX + 1): # 配る
for ib in range(ABMAX + 1):
na = ia + a
nb = ib + b
if na <= ABMAX and nb <= ABMAX:
mincost[na][nb] = min(mincost[na][nb], prevcost[ia][ib] + c)
return mincost
main()
| p03806 |
N,Ma,Mb=list(map(int,input().split()))
Med=[]
for i in range(N):
a=[int(x) for x in input().split()]
Med.append(a)
#[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(401)] for k in range(401)] for i 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]==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) | N,Ma,Mb=list(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]
R=max(cnt_a,cnt_b)
#[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(R+1)] for k in range(R+1)] for i in range(N+1)]
dp[0][0][0]=0
for i in range(N):
for j in range(R+1):
for k in range(R+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<R+1 and i*Mb<R+1:
ans=min(ans,dp[N][i*Ma][i*Mb])
if ans==float('inf'):
print((-1))
else:
print(ans) | p03806 |
def sol():
N, Ma, Mb = list(map(int, input().split()))
items = []
for _ in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
dp = [[[[]] for _ in range(Ma)] for _ in range(N + 1)]
for i, (a, _, _) in enumerate(items):
for mod in range(Ma):
for prev in dp[i][mod]:
dp[i + 1][mod].append(prev)
for prev in dp[i][(mod - a) % Ma]:
dp[i + 1][mod].append(prev + [i])
maList = [A for A in dp[N][0] if len(A) > 0]
ans = float('inf')
for addList in maList:
sumA = 0
sumB = 0
cost = 0
for i in addList:
sumA += items[i][0]
sumB += items[i][1]
cost += items[i][2]
if sumA * Mb == sumB * Ma:
ans = min(ans, cost)
if ans == float('inf'):
print((-1))
else:
print(ans)
sol() | def sol():
N, Ma, Mb = list(map(int, input().split()))
items = []
for _ in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
dp = [[set([()]) for _ in range(Ma)] for _ in range(N + 1)]
for i, (a, _, _) in enumerate(items):
for mod in range(Ma):
for prev in dp[i][mod]:
dp[i + 1][mod].add(prev)
for prev in dp[i][(mod - a) % Ma]:
dp[i + 1][mod].add(tuple(list(prev) + [i]))
maList = [A for A in dp[N][0] if len(A) > 0]
ans = float('inf')
for addList in maList:
sumA = 0
sumB = 0
cost = 0
for i in addList:
sumA += items[i][0]
sumB += items[i][1]
cost += items[i][2]
if sumA * Mb == sumB * Ma:
ans = min(ans, cost)
if ans == float('inf'):
print((-1))
else:
print(ans)
sol() | p03806 |
N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(map(int, input().split()))
items.append((a, b, c))
inf = float("inf")
dp = [[[inf for _ in range(411)] for _ in range(411)] 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)) | N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(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 + 100)] for _ in range(b_sum + 100)] 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):
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))
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(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 + 100)] for _ in range(b_sum + 100)] 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):
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))
| N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(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 + 60)] for _ in range(b_sum + 60)] 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))
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(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 + 50)] for _ in range(b_sum + 50)] 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))
| N, Ma, Mb = list(map(int, input().split()))
items = []
for i in range(N):
a, b, c = list(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(b_sum + 11)] for _ in range(a_sum + 11)] 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))
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
items = []
ap = items.append
a_sum =0
b_sum = 0
for i in range(N):
a, b, c = list(map(int, input().split()))
ap((a, b, c))
a_sum += a
b_sum += b
inf = float("inf")
dp = [[[inf for _ in range(b_sum + 10)] for _ in range(a_sum + 10)] 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):
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))
| N, Ma, Mb = list(map(int, input().split()))
items = []
ap = items.append
a_sum =0
b_sum = 0
for i in range(N):
a, b, c = list(map(int, input().split()))
ap((a, b, c))
a_sum += a
b_sum += b
inf = float("inf")
dp = [[[inf for _ in range(b_sum + 10)] for _ in range(a_sum + 10)] 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))
| p03806 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
from itertools import product
from copy import deepcopy
def resolve():
n,ma,mb=list(map(int,input().split()))
ABC=[tuple(map(int,input().split())) for _ in range(n)]
M=400
dp=[[INF]*(M+1) for _ in range(M+1)]
dp[0][0]=0
for a,b,c in ABC:
ndp=deepcopy(dp)
for x,y in product(list(range(M+1)),repeat=2):
if(x+a<=M and y+b<=M):
ndp[x+a][y+b]=min(ndp[x+a][y+b],dp[x][y]+c)
dp=ndp
ans=INF
for x,y in product(list(range(1,M+1)),repeat=2):
if(x*mb==y*ma): ans=min(ans,dp[x][y])
if(ans==INF): ans=-1
print(ans)
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
from itertools import product
from copy import deepcopy
def resolve():
n,ma,mb=list(map(int,input().split()))
ABC=[tuple(map(int,input().split())) for _ in range(n)]
M=400
dp=[[INF]*(M+1) for _ in range(M+1)]
dp[0][0]=0
for a,b,c in ABC:
for x,y in product(list(range(M,-1,-1)),repeat=2):
if(x+a<=M and y+b<=M):
dp[x+a][y+b]=min(dp[x+a][y+b],dp[x][y]+c)
ans=INF
for x,y in product(list(range(1,M+1)),repeat=2):
if(x*mb==y*ma): ans=min(ans,dp[x][y])
if(ans==INF): ans=-1
print(ans)
resolve() | p03806 |
from copy import deepcopy
N, Ma, Mb = list(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 = list(map(int, input().split()))
OldP = P.copy()
OldL = deepcopy(L)
for p in 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(OldL[p[0]+a][p[1]+b], OldL[p[0]][p[1]]+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))
| N, Ma, Mb = list(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 = list(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))
| p03806 |
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
N,Ma,Mb = list(map(int,input().split()))
abc = [list(map(int,input().split())) for i in range(N)]
INF = N * 100 + 1
dp = [[[INF for cb in range(411)] for ca in range(411)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for ca in range(N*10):
for cb in range(N*10):
dp[i+1][ca][cb] = min(dp[i+1][ca][cb],dp[i][ca][cb])
d = abc[i]
dp[i+1][ca+d[0]][cb+d[1]] = min(dp[i+1][ca+d[0]][cb+d[1]],dp[i][ca][cb]+d[2])
res = INF
for ca in range(1,401):
for cb in range(1,401):
if ca * Mb == cb * Ma:
res = min(res,dp[N][ca][cb])
if res == INF:
res = -1
print(res)
main()
| # import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
N,Ma,Mb = list(map(int,input().split()))
abc = [list(map(int,input().split())) for i in range(N)]
INF = N * 100 + 1
dp = [[[INF for cb in range(411)] for ca in range(411)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
for ca in range(N*10):
for cb in range(N*10):
if dp[i][ca][cb] == INF:
continue
dp[i+1][ca][cb] = min(dp[i+1][ca][cb],dp[i][ca][cb])
d = abc[i]
dp[i+1][ca+d[0]][cb+d[1]] = min(dp[i+1][ca+d[0]][cb+d[1]],dp[i][ca][cb]+d[2])
res = INF
for ca in range(1,401):
for cb in range(1,401):
if ca * Mb == cb * Ma:
res = min(res,dp[N][ca][cb])
if res == INF:
res = -1
print(res)
main()
| p03806 |
n,ma,mb = list(map(int, input().split()))
abcl = []
for _ in range(n):
a,b,c = list(map(int, input().split()))
abcl.append((a,b,c))
dp = [ [ [10**9]*401 for _ in range(401) ] for _ in range(n+1) ]
dp[0][0][0] = 0
for i in range(n):
ai,bi,ci = abcl[i]
for a in range(401):
for b in range(401):
if a+ai < 401 and b+bi < 401:
dp[i+1][a][b] = min(dp[i][a][b], dp[i+1][a][b])
dp[i+1][a+ai][b+bi] = min(dp[i][a][b] + ci, dp[i+1][a+ai][b+bi])
ans = 10**9
dp_row = dp[n]
for a in range(1,401):
for b in range(1,401):
if ma*b == mb*a:
v = dp[n][a][b]
ans = min(ans,v)
if ans == 10**9: ans = -1
print(ans) | n,ma,mb = list(map(int, input().split()))
abcl = []
for _ in range(n):
a,b,c = list(map(int, input().split()))
abcl.append((a,b,c))
dp = [ [ [10**9]*401 for _ in range(401) ] for _ in range(n+1) ]
dp[0][0][0] = 0
for i in range(n):
ai,bi,ci = abcl[i]
for a in range(401):
for b in range(401):
dp[i+1][a][b] = min(dp[i][a][b], dp[i+1][a][b])
if a+ai < 401 and b+bi < 401:
dp[i+1][a+ai][b+bi] = min(dp[i][a][b] + ci, dp[i+1][a+ai][b+bi])
ans = 10**9
dp_row = dp[n]
for a in range(1,401):
for b in range(1,401):
if ma*b == mb*a:
v = dp[n][a][b]
ans = min(ans,v)
if ans == 10**9: ans = -1
print(ans) | p03806 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, a_ratio, b_ratio = LI()
L = LIR(n)
A, B, cost = [[L[i][j] for i in range(n)] for j in range(3)]
dp = [[INF] * 401 for _ in range(401)]
dp[0][0] = 0
for i in range(n):
for j in range(401, -1, -1):
for k in range(401, -1, -1):
if 0 <= j + A[i] <= 400 and 0 <= k + B[i] <= 400:
dp[j + A[i]][k + B[i]] = min(dp[j + A[i]][k + B[i]], dp[j][k] + cost[i])
ans = INF
for l in range(1, min(400 // b_ratio, 400 // a_ratio)):
ans = min(ans, dp[a_ratio * l][b_ratio * l])
if ans == INF:
print((-1))
else:
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
def gcd(i, j):
while j:
i, j = j, i % j
return i
n, a_ratio, b_ratio = LI()
solution = LIR(n)
dp = {(0, 0): 0}
for a, b, c in solution:
for (ai, bi), ci in list(dp.items()):
# listにしないとduring iteration dictionary changeみたいなerrorでる。
# メモ：defaultdictはもともと存在しないkeyを参照するだけでkey:valueが追加される。
# これによって、key: INFが追加されるのはまずい。だからgetで
dp[(ai + a, bi + b)] = min(dp.get((ai + a, bi + b), INF), ci + c)
ans = INF
for i in range(1, max(400 // a_ratio, 400 // b_ratio)):
ans = min(ans, dp.get((a_ratio * i, b_ratio * i), INF))
print((ans if ans != INF else -1))
| p03806 |
N, Ma, Mb = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in range(N)]
inf = float('inf')
dp = [[[inf] * 401 for _ in range(401)] for _ in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
for j in range(401):
for k in range(401):
dp[i + 1][j][k] = dp[i][j][k]
if j - abc[i][0] >= 0 and k - abc[i][1] >= 0:
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j - abc[i][0]][k - abc[i][1]] + abc[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:
ans = -1
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in range(N)]
inf = float('inf')
dp = [[[inf] * 401 for _ in range(401)] for _ 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 j - abc[i][0] >= 0 and k - abc[i][1] >= 0:
dp[i + 1][j][k] = min(dp[i][j][k], dp[i][j - abc[i][0]][k - abc[i][1]] + abc[i][2])
else:
dp[i + 1][j][k] = dp[i][j][k]
ans = inf
for a in range(1, 401):
if a % Ma == 0:
b = a // Ma * Mb
if b <= 401:
ans = min(ans, dp[N][a][b])
if ans == inf:
ans = -1
print(ans)
| p03806 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
# Ma:Mbを満たす量を全探索する
# 量を決めたときの最小予算は半分全列挙から分かる
from itertools import product
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
Z1 = list(product([0,1],repeat=N//2))
Z2 = list(product([0,1],repeat=N-N//2))
d1 = defaultdict(list)
d2 = defaultdict(list)
for z in Z1:
val_a = 0
val_b = 0
cost = 0
for i,z0 in enumerate(z):
if z0:
val_a += a[i]
val_b += b[i]
cost += c[i]
d1[(val_a,val_b)].append(cost)
for k in list(d1.keys()):
d1[k].sort()
for z in Z2:
val_a = 0
val_b = 0
cost = 0
for i,z0 in enumerate(z):
if z0:
val_a += a[N//2+i]
val_b += b[N//2+i]
cost += c[N//2+i]
d2[(val_a,val_b)].append(cost)
for k in list(d2.keys()):
d2[k].sort()
vals = []
now = 1
while True:
if Ma*now <= sum(a) and Mb*now <= sum(b):
vals.append((Ma*now,Mb*now))
now += 1
else:
break
ans = float('inf')
for v in vals:
for k in list(d1.keys()):
left_a = v[0]-k[0]
left_b = v[1]-k[1]
if d2[(left_a,left_b)]:
if d1[k][0]+d2[(left_a,left_b)][0] < ans:
ans = d1[k][0]+d2[(left_a,left_b)][0]
if ans == float('inf'):
print((-1))
else:
print(ans) | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
amax = sum(a)
bmax = sum(b)
# dp[i][j][k]: 薬品iまで見て，Aがjグラム，Bがkグラムの最小予算
dp = [[[5000]*(bmax+1) for _ in range(amax+1)] for _ in range(N)]
dp[0][a[0]][b[0]] = c[0]
dp[0][0][0] = 0
for i in range(1,N):
for j in range(amax+1):
for k in range(bmax+1):
if j == k == 0:
dp[i][j][k] = 0
elif j-a[i] < 0 or k-b[i] < 0:
dp[i][j][k] = dp[i-1][j][k]
else:
dp[i][j][k] = min(dp[i-1][j][k], dp[i-1][j-a[i]][k-b[i]]+c[i])
ans = 5000
now = 1
while True:
if Ma*now <= amax and Mb*now <= bmax:
if dp[N-1][Ma*now][Mb*now] < ans:
ans = dp[N-1][Ma*now][Mb*now]
now += 1
else:
break
if ans == 5000:
print('-1')
else:
print(ans) | p03806 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
from itertools import product
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
Z1 = list(product([0,1],repeat=N//2))
Z2 = list(product([0,1],repeat=N-N//2))
d1 = defaultdict(lambda:5000)
d2 = defaultdict(lambda:5000)
for z in Z1:
val_a = 0
val_b = 0
cost = 0
for i,z0 in enumerate(z):
if z0:
val_a += a[i]
val_b += b[i]
cost += c[i]
if cost < d1[(val_a,val_b)]:
d1[(val_a,val_b)] = cost
for z in Z2:
val_a = 0
val_b = 0
cost = 0
for i,z0 in enumerate(z):
if z0:
val_a += a[N//2+i]
val_b += b[N//2+i]
cost += c[N//2+i]
if cost < d2[(val_a,val_b)]:
d2[(val_a,val_b)] = cost
vals = []
now = 1
while True:
if Ma*now <= sum(a) and Mb*now <= sum(b):
vals.append((Ma*now,Mb*now))
now += 1
else:
break
ans = 5000
for k in list(d1.keys()):
for v in vals[::-1]:
left_a = v[0]-k[0]
left_b = v[1]-k[1]
if left_a < 0 or left_b < 0:
break
if d1[k]+d2[(left_a,left_b)] < ans:
ans = d1[k]+d2[(left_a,left_b)]
if ans == 5000:
print((-1))
else:
print(ans) | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
n = N//2
d1 = defaultdict(lambda:5000)
d2 = defaultdict(lambda:5000)
for bit in range(1<<n):
val_a = 0
val_b = 0
cost = 0
for i in range(n):
if bit>>i&1:
val_a += a[n-1-i]
val_b += b[n-1-i]
cost += c[n-1-i]
if cost < d1[(val_a,val_b)]:
d1[(val_a,val_b)] = cost
for bit in range(1<<(N-n)):
val_a = 0
val_b = 0
cost = 0
for i in range(N-n):
if bit>>i&1:
val_a += a[N-1-i]
val_b += b[N-1-i]
cost += c[N-1-i]
if cost < d2[(val_a,val_b)]:
d2[(val_a,val_b)] = cost
vals = []
now = 1
while True:
if Ma*now <= sum(a) and Mb*now <= sum(b):
vals.append((Ma*now,Mb*now))
now += 1
else:
break
ans = 5000
for k in list(d1.keys()):
for v in vals[::-1]:
left_a = v[0]-k[0]
left_b = v[1]-k[1]
if left_a < 0 or left_b < 0:
break
if d1[k]+d2[(left_a,left_b)] < ans:
ans = d1[k]+d2[(left_a,left_b)]
if ans == 5000:
print((-1))
else:
print(ans) | p03806 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
n = N//2
d1 = [[5000]*401 for _ in range(401)]
d2 = [[5000]*401 for _ in range(401)]
for bit in range(1<<n):
val_a = 0
val_b = 0
cost = 0
for i in range(n):
if bit>>i&1:
val_a += a[n-1-i]
val_b += b[n-1-i]
cost += c[n-1-i]
d1[val_a][val_b] = min(d1[val_a][val_b],cost)
for bit in range(1<<(N-n)):
val_a = 0
val_b = 0
cost = 0
for i in range(N-n):
if bit>>i&1:
val_a += a[N-1-i]
val_b += b[N-1-i]
cost += c[N-1-i]
d2[val_a][val_b] = min(d2[val_a][val_b],cost)
vals = []
now = 1
while True:
if Ma*now <= sum(a) and Mb*now <= sum(b):
vals.append((Ma*now,Mb*now))
now += 1
else:
break
ans = 5000
for ka in range(401):
for kb in range(401):
for v in vals[::-1]:
left_a = v[0]-ka
left_b = v[1]-kb
if left_a < 0 or left_b < 0:
break
if d1[ka][kb]+d2[left_a][left_b] < ans:
ans = d1[ka][kb]+d2[left_a][left_b]
if ans == 5000:
print((-1))
else:
print(ans) | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
N,Ma,Mb = LI()
a,b,c = LIR(N,3)
n = N//2
d1 = [[5000]*401 for _ in range(401)]
d2 = [[5000]*401 for _ in range(401)]
for bit in range(1<<n):
val_a = 0
val_b = 0
cost = 0
for i in range(n):
if bit>>i&1:
val_a += a[n-1-i]
val_b += b[n-1-i]
cost += c[n-1-i]
d1[val_a][val_b] = min(d1[val_a][val_b],cost)
for bit in range(1<<(N-n)):
val_a = 0
val_b = 0
cost = 0
for i in range(N-n):
if bit>>i&1:
val_a += a[N-1-i]
val_b += b[N-1-i]
cost += c[N-1-i]
d2[val_a][val_b] = min(d2[val_a][val_b],cost)
vals = []
now = 1
while True:
if Ma*now <= sum(a) and Mb*now <= sum(b):
vals.append((Ma*now,Mb*now))
now += 1
else:
break
ans = 5000
for ka in range(401):
for kb in range(401):
if d1[ka][kb] != 5000:
for v in vals[::-1]:
left_a = v[0]-ka
left_b = v[1]-kb
if left_a < 0 or left_b < 0:
break
if d1[ka][kb]+d2[left_a][left_b] < ans:
ans = d1[ka][kb]+d2[left_a][left_b]
if ans == 5000:
print((-1))
else:
print(ans) | p03806 |
n,ma,mb=list(map(int,input().split()))
abc=[list(map(int,input().split())) for _ in [0]*n]
memo=[[10**5 for _ in [0]*401] for _ in [0]*401]
memo[0][0]=0
for N in range(n):
for i in range(390,-1,-1):
for j in range(390,-1,-1):
a,b,c=abc[N]
memo[i+a][j+b]=min(memo[i+a][j+b],memo[i][j]+c)
m=10**4
for i in range(1,400):
for j in range(1,400):
if i*mb==ma*j:
m=min(m,memo[i][j])
if m==10**4:
print((-1))
else:
print(m) | n,ma,mb=list(map(int,input().split()))
abc=[list(map(int,input().split())) for _ in [0]*n]
memo=[[10**4 for _ in [0]*(n*10+1)] for _ in [0]*(n*10+1)]
memo[0][0]=0
for N in range(n):
for i in range(N*10,-1,-1):
for j in range(N*10,-1,-1):
a,b,c=abc[N]
memo[i+a][j+b]=min(memo[i+a][j+b],memo[i][j]+c)
m=10**4
for i in range(1,n*10):
for j in range(1,n*10):
if i*mb==ma*j:
m=min(m,memo[i][j])
if m==10**4:
print((-1))
else:
print(m) | p03806 |
#D問題
NM=40
ABM=10
N,M1,M2=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)
amax,bmax,cmax,=max(A),max(B),max(C)
dp=[[[N*cmax for broop in range(NM*ABM+1)] for aroop in range(NM*ABM+1)] for nroop in range(NM+1)]
dp[0][0][0]=0
for i in range(N):
for cb in range(NM*ABM):
for ca in range(NM*ABM):
dp[i+1][ca][cb]=min(dp[i+1][ca][cb],dp[i][ca][cb])
if ca+A[i]<NM*ABM and cb+B[i]<NM*ABM:
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=N*cmax
for cb in range(NM*ABM):
CB=cb+1
for ca in range(NM*ABM):
CA=ca+1
if ca*M2 == cb*M1:
ans=min(ans,dp[N][CA][CB])
if ans == N*cmax:
print((-1))
else:
print(ans) | #D問題
NM=40
ABM=10
MM=400
N,M1,M2=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)
cmax=max(C)
CM=N*cmax+10
dp=[[[CM for broop in range(401)] for aroop in range(401)] for nroop in range(N+1)]
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]<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):
for ca in range(400):
CB=cb+1
CA=ca+1
if CA*M2 == CB*M1:
ans=min(ans,dp[N][CA][CB])
if ans == CM:
print((-1))
else:
print(ans) | p03806 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n, ma, mb = list(map(int, input().split()))
abc = [None]*n
for i in range(n):
a,b,c = tuple(map(int, input().split()))
abc[i] = (a*mb - b*ma, c)
abc.sort()
def halfcomb(l):
n = len(l)
n1 = n//2
n2 = (n+1)//2
l1 = []
l2 = []
for b in range(1, 1<<n2):
v11, v12 = 0, 0
v21, v22 = 0, 0
for i in range(n2):
if b&1<<i:
item = l[n1+i]
v21+=item[0]
v22+=item[1]
if b<(1<<n1) and i<n1:
item = l[i]
v11+=item[0]
v12+=item[1]
if b<(1<<n1):
l1.append((v11,v12))
l2.append((v21,v22))
return l1, l2
l1, l2 = halfcomb(abc)
d2 = {}
for v,c in l2:
if v in d2:
d2[v] = min(d2[v], c)
else:
d2[v] = c
ans = float("inf")
for v,c in l1:
if v==0:
ans = min(ans, c)
for v,c in l2:
if v==0:
ans = min(ans, c)
for v,c in l1:
if -v in d2:
ans = min(ans, c+d2[-v])
if ans == float("inf"):
ans = -1
print(ans) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n, ma, mb = list(map(int, input().split()))
abc = [None]*n
for i in range(n):
a,b,c = tuple(map(int, input().split()))
abc[i] = (a*mb - b*ma, c)
abc.sort()
def halfcomb(l):
n = len(l)
n1 = n//2
n2 = (n+1)//2
l1 = []
l2 = []
def sub(v1, v2, i, bound, ll, ind=0):
if i==bound:
ll.append((v1,v2))
return
sub(v1, v2, i+1, bound, ll, ind)
sub(v1+l[ind+i][0], v2+l[ind+i][1], i+1, bound, ll, ind)
sub(0, 0, 0, n1, l1)
sub(0, 0, 0, n2, l2, ind=n1)
return l1, l2
l1, l2 = halfcomb(abc)
d2 = {}
for v,c in l2:
if v in d2:
d2[v] = min(d2[v], c)
else:
d2[v] = c
ans = float("inf")
for v,c in l1:
if v==0 and c>0:
ans = min(ans, c)
for v,c in l2:
if v==0 and c>0:
ans = min(ans, c)
for v,c in l1:
if -v in d2 and c+d2[-v]>0:
ans = min(ans, c+d2[-v])
if ans == float("inf"):
ans = -1
print(ans) | p03806 |
N, Ma, Mb = list(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] * (N_max * b_max + 1) for _ in range(N_max * a_max + 1)]
dp[0][0] = 0
for i, (aa, bb, cc) in enumerate(e):
for a in reversed(list(range(a_max * i + 1))):
for b in reversed(list(range(b_max * i + 1))):
if dp[a][b] == inf: continue
if a + aa < N_max * a_max + 1 and b + bb < N_max * b_max + 1:
dp[a + aa][b + bb] = min(dp[a + aa][b + bb], dp[a][b] + cc)
ans = inf
for i in range(1, N_max * a_max + 1):
if i * Ma >= N_max * a_max + 1 or i * Mb >= N_max * b_max + 1: break
# a:b=Ma:Mb
# b*Ma=a*Mb
ans = min(ans, dp[i * Ma][i * Mb])
print((ans if ans < inf else -1))
| inf = float('inf')
N, Ma, Mb = list(map(int, input().split()))
dp = [[inf] * (400 + 1) for _ in range(400 + 1)]
dp[0][0] = 0
max_a = 0
max_b = 0
for i in range(N):
a, b, c = list(map(int, input().split()))
max_a += a
max_b += b
for j in reversed(list(range(max_a + 1 - a))):
for k in range(max_b + 1 - b):
if dp[j][k] == inf: continue
dp[j + a][k + b] = min(dp[j][k] + c, dp[j + a][k + b])
j = Ma
k = Mb
ans = inf
while j < 400 + 1 and k < 400 + 1:
ans = min(ans, dp[j][k])
j += Ma
k += Mb
print((-1 if ans == inf else ans))
# print(dp)
| p03806 |
def main():
inf = 100 * 40 + 1
mx = 400
N, Ma, Mb = list(map(int, input().split()))
dp = [[[inf] * (400 + 1) for _ in range(400 + 1)] for _ in range(N + 1)]
dp[0][0][0] = 0
for i in range(N):
ai, bi, ci = list(map(int, input().split()))
for a in range(mx + 1):
for b in range(mx + 1):
dp[i + 1][a][b] = dp[i][a][b]
for a in range(ai, mx + 1):
for b in range(bi, mx + 1):
dp[i + 1][a][b] = min(
dp[i + 1][a][b],
dp[i][a - ai][b - bi] + ci
)
k = 1
ans = inf
while Ma * k <= mx and Mb * k <= mx:
ans = min(ans, dp[N][Ma * k][Mb * k])
k += 1
if ans == inf:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
| def main():
INF = 100 * 40 + 1
MX = 4000
N, Ma, Mb = list(map(int, input().split()))
dp = [[INF] * (MX * 2 + 1) for _ in range(2)]
i, j = 0, 1
for _ in range(N):
ai, bi, ci = list(map(int, input().split()))
x = Ma * bi - Mb * ai # Σai:Σbi=Ma:Mb<->Ma*Σbi-Mb*Σai=0
for k in range(-MX, MX + 1):
dp[j][k] = dp[i][k]
dp[j][x] = min(dp[j][x], ci)
for k in range(-MX + x, MX + 1):
dp[j][k] = min(
dp[j][k],
dp[i][k - x] + ci
)
i, j = j, i
res = dp[i][0]
print((-1 if res == INF else res))
if __name__ == '__main__':
main()
| p03806 |
def main():
INF = 100 * 40 + 1
MX = 4000
N, Ma, Mb = list(map(int, input().split()))
dp = [[INF] * (MX * 2 + 1) for _ in range(2)]
i, j = 0, 1
for _ in range(N):
ai, bi, ci = list(map(int, input().split()))
x = Ma * bi - Mb * ai # Σai:Σbi=Ma:Mb<->Ma*Σbi-Mb*Σai=0
for k in range(-MX, MX + 1):
dp[j][k] = dp[i][k]
dp[j][x] = min(dp[j][x], ci)
for k in range(-MX + x, MX + 1):
dp[j][k] = min(
dp[j][k],
dp[i][k - x] + ci
)
i, j = j, i
res = dp[i][0]
print((-1 if res == INF else res))
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc054/submissions/4360181
def main():
from collections import defaultdict
INF = 40 * 100 + 1
N, Ma, Mb = list(map(int, input().split()))
memo = defaultdict(lambda: INF)
for _ in range(N):
ai, bi, ci = list(map(int, input().split()))
x = Ma * bi - Mb * ai # Σai:Σbi=Ma:Mb<->Ma*Σbi-Mb*Σai=0
for key, value in tuple(memo.items()):
memo[key + x] = min(
memo[key + x],
value + ci
) # 既存の組み合わせに混合
memo[x] = min(memo[x], ci) # 新規のみ
print((memo[0] if 0 in memo else -1))
if __name__ == '__main__':
main()
| p03806 |
#!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(sb+1)] for j in range(sa+1)] for k in range(n+1)]
dp[0][0][0] = 0
for i 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][a+ai][b+bi] = min(dp[i+1][a+ai][b+bi],dp[i][a][b]+ci,dp[i][a+ai][b+bi])
dp[i+1][a][b] = min(dp[i+1][a][b],dp[i][a][b])
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 a,b in li:
ans = min(ans,dp[n][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
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,A,B = LI()
G = LIR(n)
n1 = n>>1
n2 = n-n1
s1 = defaultdict(lambda : float("inf"))
s2 = defaultdict(lambda : float("inf"))
for j in range(1<<n1):
sa = 0
sb = 0
sc = 0
for i in range(n1):
if j&(1<<i):
a,b,c = G[i]
sa += a
sb += b
sc += c
if s1[(sa,sb)] > sc:
s1[(sa,sb)] = sc
m = 1
for j in range(1<<n2):
sa = 0
sb = 0
sc = 0
for i in range(n2):
if j&(1<<i):
a,b,c = G[i+n1]
sa += a
sb += b
sc += c
if sa > m:
m = sa
if s2[(sa,sb)] > sc:
s2[(sa,sb)] = sc
ans = float("inf")
for (a,b),c in list(s1.items()):
for i in range(m+1):
s = B*(i+a)
if s%A:
continue
j = (s//A)-b
nc = s2[(i,j)]
cost = c+nc
if a == b == i == j:
continue
if cost < ans:
ans = cost
if ans == float("inf"):
print((-1))
return
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p03806 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,A,B = LI()
G = LIR(n)
ma = sum([a for (a,_,_) in G])
mb = sum([b for (_,b,_) in G])
dp = [[float("inf")]*(mb+1) for i in range(ma+1)]
dp[0][0] = 0
for a,b,c in G:
for sa in range(ma)[::-1]:
for sb in range(mb)[::-1]:
na = sa+a
if na > ma:
continue
nb = sb+b
if nb > mb:
continue
nd = dp[sa][sb]+c
if nd < dp[na][nb]:
dp[na][nb] = nd
ans = float("inf")
for i in range(1,ma+1):
s = B*i
if s%A:
continue
j = B*i//A
if j > mb:
continue
if dp[i][j] < ans:
ans = dp[i][j]
if ans == float("inf"):
print((-1))
return
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,A,B = LI()
G = LIR(n)
ma = sum([a for (a,_,_) in G])
mb = sum([b for (_,b,_) in G])
dp = [float("inf")]*((ma+1)*mb+1)
dp[0] = 0
for a,b,c in G:
for sa in range(ma)[::-1]:
na = sa+a
if na > ma:
continue
for sb in range(mb)[::-1]:
nb = sb+b
if nb > mb:
continue
nd = dp[sa*mb+sb]+c
i = na*mb+nb
if nd < dp[i]:
dp[i] = nd
ans = float("inf")
for i in range(1,ma+1):
s = B*i
if s%A:
continue
j = B*i//A
if j > mb:
continue
k = i*mb+j
if dp[k] < ans:
ans = dp[k]
if ans == float("inf"):
print((-1))
return
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p03806 |
def main():
n,ma,mb = list(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(1,n+1):
a,b,c = list(map(int,input().split()))
for j in range(401):
for k in range(401):
if a<=j and b<=k:
dp[i][j][k] = min(dp[i-1][j][k],dp[i-1][j-a][k-b]+c)
else:
dp[i][j][k] = dp[i-1][j][k]
ans = float("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==float("inf"):
print((-1))
else:
print(ans)
if __name__ == "__main__":
main()
| n,ma,mb=list(map(int,input().split()))
dp=[[[10**30 for j in range(401)]for i in range(401)]for k in range(n+1)]
dp[0][0][0]=0
l=[]
for i in range(n):
a,b,c=list(map(int,input().split()))
l.append([a,b,c])
for i in range(1,n+1):
a,b,c=l[i-1][0],l[i-1][1],l[i-1][2]
for x in range(401):
for y in range(401):
if x<a or y<b:
dp[i][x][y]=dp[i-1][x][y]
continue
dp[i][x][y]=min(dp[i-1][x][y],dp[i-1][x-a][y-b]+c)
mini=10**30
for i in range(1,40):
mini=min(mini,dp[n][ma*i][mb*i])
if mini>=10**30 :
print((-1))
else:
print(mini) | p03806 |
import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
INF = float("inf")
sys.setrecursionlimit(10 ** 7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def main():
N, Ma, Mb = list(map(int, input().split()))
dp = [[[INF] * 401 for j in range(401)] for i in range(N + 1)]
dp[0][0][0] = 0
a_b_c = [list(map(int, input().split())) for _ in range(N)]
for i, (a, b, c) in enumerate(a_b_c):
for j in range(len(dp[0])):
for k in range(len(dp[0][0])):
# not use
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k])
# use
if j + a < len(dp[0]) and k + b < len(dp[0][0]):
dp[i + 1][j + a][k + b] = min(dp[i + 1][j + a][k + b], dp[i][j][k] + c)
ans = INF
for i in count(1):
a, b = Ma * i, Mb * i
if a >= len(dp[0]) or b >= len(dp[0][0]):
break
ans = min(ans, dp[-1][a][b])
if ans != INF:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main()
| import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
INF = float("inf")
sys.setrecursionlimit(10 ** 7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def main():
N, Ma, Mb = list(map(int, input().split()))
dp = [[[INF] * 401 for j in range(401)] for i in range(N + 1)]
dp[0][0][0] = 0
a_b_c = [list(map(int, input().split())) for _ in range(N)]
for i, (a, b, c) in enumerate(a_b_c):
for j in range(len(dp[0])):
for k in range(len(dp[0][0])):
if dp[i][j][k] == INF:
continue
# not use
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k])
# use
if j + a < len(dp[0]) and k + b < len(dp[0][0]):
dp[i + 1][j + a][k + b] = min(dp[i + 1][j + a][k + b], dp[i][j][k] + c)
ans = INF
for i in count(1):
a, b = Ma * i, Mb * i
if a >= len(dp[0]) or b >= len(dp[0][0]):
break
ans = min(ans, dp[-1][a][b])
if ans != INF:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main()
| p03806 |
from collections import defaultdict
MAX = 40001
def main():
N, Ma, Mb = [int(a) for a in input().split()]
abc = [
[int(a) for a in input().split()]
for _ in range(N)
]
dp = [
[
[MAX for b in range(10 * N + 1)]
for a in range(10 * N + 1)
]
for i in range(N)
] # dp[i][a][b] = i番目までを使ってaグラムbグラムを作る最小コスト
a, b, c = abc[0]
dp[0][a][b] = c
dp[0][0][0] = 0
for i in range(1, N):
a, b, c = abc[i]
for j in range(10 * N):
for k in range(10 * N):
tukawanai = dp[i - 1][j][k]
if j - a >= 0 and k - b >= 0 and dp[i - 1][j - a][k - b] != MAX:
tukau = dp[i - 1][j - a][k - b] + c
dp[i][j][k] = min(tukawanai, tukau)
else:
dp[i][j][k] = tukawanai
res = MAX
l = dp[-1]
for a in range(1,10 * N+1):
aa = a * Mb
if aa % Ma != 0:
continue
b = aa // Ma
if b >= len(l[a]):
continue
c = l[a][b]
res = min(res, c)
if res == MAX:
res = -1
print(res)
if __name__ == '__main__':
main()
| from collections import defaultdict
MAX = 40001
def main():
N, Ma, Mb = [int(a) for a in input().split()]
abc = [
[int(a) for a in input().split()]
for _ in range(N)
]
dp = [
[
[MAX for b in range(10 * N + 1)]
for a in range(10 * N + 1)
]
for i in range(N)
] # dp[i][a][b] = i番目までを使ってaグラムbグラムを作る最小コスト
A, B, C = abc[0]
# dp[0][a][b] = c
# dp[0][0][0] = 0
mem = {(0, A, B): C, (0, 0, 0): 0}
def solve(i, a, b):
if (i, a, b) in mem:
return mem[(i, a, b)]
if i == 0:
return MAX
ai, bi, ci = abc[i]
tukawanai = solve(i - 1, a, b)
if a - ai >= 0 and b - bi >= 0:
pre = solve(i - 1, a - ai, b - bi)
if pre != MAX:
mem[(i, a, b)] = min(tukawanai, pre + ci)
return mem[(i, a, b)]
mem[(i, a, b)] = tukawanai
return mem[(i, a, b)]
res = MAX
for a in range(1, 10 * N + 1):
aa = a * Mb
if aa % Ma != 0:
continue
b = aa // Ma
if b >= 10 * N + 1:
continue
c = solve(N - 1, a, b)
res = min(res, c)
if res == MAX:
res = -1
print(res)
if __name__ == '__main__':
main()
| p03806 |
from collections import defaultdict
N,Ma,Mb=list(map(int,input().split()))
A=[]
B=[]
C=[]
a_sum=0
b_sum=0
for i in range(N):
a,b,c=list(map(int,input().split()))
A.append(a)
B.append(b)
C.append(c)
a_sum+=a
b_sum+=b
dp=defaultdict(lambda: float("inf"))
dp[(0,0,0)]=0
for k in range(1,N+1):
for x in range(a_sum+1):
for y in range(b_sum+1):
dp[(k,x,y)]=min( dp[(k,x,y)], dp[(k-1,x,y)] )
if x-A[k-1]>=0 and y-B[k-1]>=0:
dp[(k,x,y)]=min( dp[(k-1,x,y)], dp[(k-1, x-A[k-1], y-B[k-1])]+C[k-1] )
ans=float("inf")
for x in range(1,a_sum+1):
for y in range(1,b_sum+1):
if x*Mb==y*Ma:
ans=min(ans,dp[(N, x, y)])
if ans==float("inf"):
print(-1)
else:
print(ans)
| from collections import defaultdict
N,Ma,Mb=list(map(int,input().split()))
dp=defaultdict(lambda: float("inf"))
dp[(0,0)]=0
for i in range(N):
a,b,c=list(map(int,input().split()))
for j in list(dp.items()):
x=j[0][0]
y=j[0][1]
z=j[1]
na, nb, nc = x+a, y+b, z+c
dp[(na, nb)]=min( dp[(na, nb)], nc)
ans=float("inf")
for i in list(dp.items()):
x=i[0][0]
y=i[0][1]
z=i[1]
if x==0 and y==0:
continue
if x*Mb==y*Ma:
ans=min(ans,z)
else:
if ans==float("inf"):
print(-1)
else:
print(ans) | p03806 |
N,Ma,Mb=list(map(int,input().split()))
a=[0 for k in range(N)]
b=[0 for k in range(N)]
c=[0 for k in range(N)]
import copy
for k in range(N):
a[k],b[k],c[k]=list(map(int,input().split()))
Sa=sum(a)
Sb=sum(b)
dp =[[5000 for k in range(Sb+1)]for k in range(Sa+1)]
dp[0][0]=0
for k in range(N):
listj=[]
listl=[]
co=copy.deepcopy(dp)
for j in range(Sa-a[k]+1):
for l in range(Sb-b[k]+1):
if dp[j][l]!=5000:
listj.append(j)
listl.append(l)
for m in range(len(listl)):
dp[listj[m]+a[k]][listl[m]+b[k]]=min(co[listj[m]][listl[m]]+c[k], co[listj[m]+a[k]][listl[m]+b[k]])
ans=[5000]
for k in range(1, min(Sa//Ma,Sb//Mb)+1):
ans.append(dp[Ma*k][Mb*k])
if min(ans)==5000:
print((-1))
else:
print((min(ans))) | N,Ma,Mb=list(map(int,input().split()))
a=[0 for k in range(N)]
b=[0 for k in range(N)]
c=[0 for k in range(N)]
import copy
for k in range(N):
a[k],b[k],c[k]=list(map(int,input().split()))
Sa=sum(a)
Sb=sum(b)
dp =[[[5000 for k in range(Sb+1)]for k in range(Sa+1)]for k in range(N+1)]
dp[0][0][0]=0
for k in range(N):
listj=[]
listl=[]
for j in range(Sa-a[k]+1):
for l in range(Sb-b[k]+1):
if dp[k][j][l]!=5000:
listj.append(j)
listl.append(l)
for m in range(len(listl)):
dp[k+1][listj[m]+a[k]][listl[m]+b[k]]=min(dp[k][listj[m]][listl[m]]+c[k], dp[k][listj[m]+a[k]][listl[m]+b[k]])
dp[k+1][listj[m]][listl[m]]=min(dp[k][listj[m]][listl[m]], dp[k+1][listj[m]][listl[m]])
ans=[5000]
for k in range(1, min(Sa//Ma,Sb//Mb)+1):
ans.append(dp[-1][Ma*k][Mb*k])
if min(ans)==5000:
print((-1))
else:
print((min(ans))) | p03806 |
import math
def f(i):
if i == ns:
suma, sumb, sumcost = 0, 0, 0
for j in range(ns):
if s[j] == 1:
suma += x[j][0]
sumb += x[j][1]
sumcost += x[j][2]
mincost[suma][sumb] = min(mincost[suma][sumb], sumcost)
return
s[i] = 1
f(i + 1)
s[i] = 0
f(i + 1)
def g(i):
if i == nt:
global ans
suma, sumb, sumcost = 0, 0, 0
for j in range(nt):
if t[j] == 1:
suma += y[j][0]
sumb += y[j][1]
sumcost += y[j][2]
k = 1
while True:
ss, tt = k * ma - suma, k * mb - sumb
if 0 <= ss <= l and 0 <= tt <= l:
ans = min(ans, mincost[ss][tt] + sumcost)
elif l < ss or l < tt:
break
k += 1
return
t[i] = 1
g(i + 1)
t[i] = 0
g(i + 1)
n, ma, mb = list(map(int, input().split()))
ns, nt = int(math.ceil(n / 2)), n // 2
l = 10 * ns
mincost = [[114514] * (l + 5) for _ in range(l + 5)]
ans = 114514
x = [list(map(int, input().split())) for _ in range(ns)]
y = [list(map(int, input().split())) for _ in range(nt)]
s = [0] * ns
t = [0] * nt
f(0)
g(0)
print((ans if not ans == 114514 else -1)) | n, ma, mb = list(map(int, input().split()))
x = [list(map(int, input().split())) for _ in range(n)]
x.insert(0, [0, 0, 0])
inf = 114514
dp = [[[inf] * (10 * n + 1) for _ in range(10 * n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 0
suma, sumb = 0, 0
for i in range(1, n + 1):
suma += x[i][0]
sumb += x[i][1]
for j in range(suma + 1):
for k in range(sumb + 1):
dp[i][j][k] = min(dp[i][j][k], dp[i - 1][j][k])
if j >= x[i][0] and k >= x[i][1]:
dp[i][j][k] = min(dp[i - 1][j][k], dp[i - 1][j - x[i][0]][k - x[i][1]] + x[i][2])
ans = 114514
for i in range(1, 10 * n + 1):
for j in range(1, 10 * n + 1):
if i * mb == j * ma:
ans = min(ans, dp[n][i][j])
print((ans if not ans == 114514 else -1)) | p03806 |
N, Ma, Mb = list(map(int, input().split()))
a = [0]*N
b = [0]*N
c = [0]*N
INF = float("inf")
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
#dp[i][j][k]...i番目までの品物で, タイプAの物質をjグラム, タイプBの物質をkグラム調達するのに必要な費用の最小値
dp = [[[INF]*400 for _ in range(400)] for _ in range(N+1)]
dp[0][0][0] = 0
for i in range(1, N+1):
for j in range(400):
for k in range(400):
if j < a[i-1] or k < b[i-1]:
dp[i][j][k] = dp[i-1][j][k]
else:
dp[i][j][k] = min(dp[i-1][j][k], dp[i-1][j-a[i-1]][k-b[i-1]]+c[i-1])
ans = INF
for i in range(1, N+1):
for j in range(1, 400):
for k in range(1, 400):
if j*Mb == k*Ma:
ans = min(ans, dp[i][j][k])
if ans == INF:
print((-1))
else:
print(ans)
| N, Ma, Mb = list(map(int, input().split()))
a = [0]*N
b = [0]*N
c = [0]*N
INF = 10000
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
#dp[i][j][k]...i番目までの品物で, タイプAの物質をjグラム, タイプBの物質をkグラム調達するのに必要な費用の最小値
dp = [[[INF]*400 for _ in range(400)] for _ in range(N+1)]
dp[0][0][0] = 0
for i in range(1, N+1):
for j in range(400):
for k in range(400):
if j < a[i-1] or k < b[i-1]:
dp[i][j][k] = dp[i-1][j][k]
else:
dp[i][j][k] = min(dp[i-1][j][k], dp[i-1][j-a[i-1]][k-b[i-1]]+c[i-1])
ans = INF
for i in range(1, N+1):
for j in range(1, 400):
for k in range(1, 400):
if j*Mb == k*Ma:
ans = min(ans, dp[i][j][k])
if ans == INF:
print((-1))
else:
print(ans)
| p03806 |
def main():
n, ma, mb, *L = list(map(int, open(0).read().split()))
M = 1<<30
dp = [[M] * 420 for _ in range(420)]
dp[0][0] = 0
for a, b, c in zip(*[iter(L)] * 3):
for i in range(400, -1, -1):
for j in range(400, -1, -1):
t = dp[i][j] + c
if dp[i + a][j + b] > t:
dp[i + a][j + b] = t
ans = M
_ma, _mb = ma, mb
while _ma < 410 > _mb:
ans = min(ans, dp[_ma][_mb])
_ma += ma
_mb += mb
print((ans if ans < M else -1))
if __name__=="__main__":
main() | def main():
n, ma, mb, *L = list(map(int, open(0).read().split()))
M = 1 << 30
dp = [[M] * 420 for _ in range(420)]
dp[0][0] = 0
ua = ub = 15
for a, b, c in zip(*[iter(L)] * 3):
for i in range(ua, -1, -1):
for j in range(ub, -1, -1):
t = dp[i][j] + c
if dp[i + a][j + b] > t:
dp[i + a][j + b] = t
if ua < i + a:
ua = i + a
if ub < j + b:
ub = j + b
ans = M
_ma, _mb = ma, mb
while _ma < 410 > _mb:
ans = min(ans, dp[_ma][_mb])
_ma += ma
_mb += mb
print((ans if ans < M else -1))
if __name__ == "__main__":
main()
| p03806 |
global N
global Nlist
global Ma
global Mb
global minicost
minicost = 10000000
N, Ma, Mb = list(map(int,input().split()))
Nlist = []
for i in range(N):
a,b,c = list(map(int,input().split()))
Nlist.append([a,b,c])
def dvector(vector):
global Ma
global Mb
global Nlist
global minicost
if len(vector) == len(Nlist):
return 0
vector.append(1)
Masum = 0
Mbsum = 0
cost = 0
for i in range(len(vector)):
Masum+= vector[i] * Nlist[i][0]
Mbsum+= vector[i] * Nlist[i][1]
cost += vector[i] * Nlist[i][2]
if Mbsum > 0:
if Masum/Mbsum == Ma/Mb:
if minicost > cost:
minicost = cost
if cost < minicost:
dvector(vector)
vector.pop()
vector.append(0)
dvector(vector)
vector.pop()
return 0
dvector([])
if minicost == 10000000:
print("-1")
else:
print(minicost) | global N
global Nlist
global Ma
global Mb
global minicost
minicost = 10000000
N, Ma, Mb = list(map(int,input().split()))
Nlist = []
for i in range(N):
a,b,c = list(map(int,input().split()))
Nlist.append([a,b,c])
def dvector(Masum,Mbsum,cost,vector):
global Ma
global Mb
global Nlist
global minicost
if len(vector) == len(Nlist):
return 0
dvector(Masum,Mbsum,cost,vector+[0])
Masum+= Nlist[len(vector)-1][0]
Mbsum+= Nlist[len(vector)-1][1]
cost += Nlist[len(vector)-1][2]
if Mbsum > 0:
if Masum/Mbsum == Ma/Mb:
if minicost > cost:
minicost = cost
if cost < minicost:
dvector(Masum,Mbsum,cost,vector+[1])
return 0
dvector(0,0,0,[])
if minicost == 10000000:
print("-1")
else:
print(minicost) | p03806 |
n,Ma,Mb=list(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,401):
for j in range(1,401):
if i*Mb==j*Ma:
ans=min(ans,dp[n][i][j])
print((ans if ans!=inf else -1)) | n,Ma,Mb=list(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+min(400//Ma,400//Mb)):
ans=min(ans,dp[n][Ma*i][Mb*i])
print((ans if ans!=inf else -1)) | p03806 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
INF = 10**5
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
n,ma,mb = LI()
med = [LI() for _ in range(n)]
h1 = []
h2 = []
for i in range(2 ** (n//2)):
bit = 1
ta = 0
tb = 0
tc = 0
for j in range(n//2):
if i & bit:
a,b,c = med[j]
ta += a
tb += b
tc += c
bit <<= 1
dif = ta * mb - tb * ma
h1.append((dif,tc))
for i in range(2 ** (n - n//2)):
bit = 1
ta = 0
tb = 0
tc = 0
for j in range(n - n//2):
if i & bit:
a,b,c = med[j+n//2]
ta += a
tb += b
tc += c
bit <<= 1
dif = tb * ma - ta * mb
h2.append((dif,tc))
h1.sort()
h2.sort()
i = 0
ans = INF
for h,c in h1:
while h2[i][0] < h:
i += 1
if i >= len(h2): break
else:
k = i
while h2[k][0] == h:
if c != 0 or h2[k][1] != 0:
ans = min(ans,c+h2[k][1])
k += 1
if k >= len(h2): break
if i >= len(h2): break
if ans < INF:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
INF = 10**5
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
n,ma,mb = LI()
med = [LI() for _ in range(n)]
h1 = [INF] * 10000
for i in range(1,2 ** (n//2)):
bit = 1
ta = 0
tb = 0
tc = 0
for j in range(n//2):
if i & bit:
a,b,c = med[j]
ta += a
tb += b
tc += c
bit <<= 1
dif = ta * mb - tb * ma
if h1[dif] > tc: h1[dif] = tc
ans = h1[0]
for i in range(1,2 ** (n - n//2)):
bit = 1
ta = 0
tb = 0
tc = 0
for j in range(n - n//2):
if i & bit:
a,b,c = med[j+n//2]
ta += a
tb += b
tc += c
bit <<= 1
dif = tb * ma - ta * mb
if dif == 0:
ans = min(ans,tc)
else:
ans = min(ans,h1[dif]+tc)
if ans < INF:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main() | p03806 |
n,ma,mb = (int(i) for i in input().split())
dp = [[[float("inf") for i in range(10*n+1)] for i in range(10*n+1)] for i in range(n+1)]
dp[0][0][0],ans = 0,float("inf")
for i in range(1,n+1):
x,y,c = (int(l) for l in input().split())
for j in range(10*(i-1)+1):
for k in range(10*(i-1)+1):
if dp[i-1][j][k]!=float("inf"):
dp[i][j][k] = min(dp[i-1][j][k],dp[i][j][k])
dp[i][j+x][k+y] = min(dp[i][j+x][k+y],dp[i-1][j][k]+c)
for i in range(ma,10*n+1,ma):
if i*mb//ma<=10*n: ans=min(ans,dp[n][i][i*mb//ma])
if ans==float("inf"): print((-1))
else: print(ans) | n, ma, mb = list(map(int, input().split()))
INF = float("inf")
dp = [[[INF for i in range(10*n+1)] for i in range(10*n+1)] for i in range(n+1)]
dp[0][0][0],ans = 0,INF
for i in range(1,n+1):
a,b,c = (int(l) for l in input().split())
for j in range(10*(i-1)+1):
for k in range(10*(i-1)+1):
if dp[i-1][j][k] != INF:
dp[i][j][k] = min(dp[i][j][k], dp[i-1][j][k])
dp[i][j+a][k+b] = min(dp[i][j+a][k+b], dp[i-1][j][k]+c)
for i in range(ma,10*n+1,ma):
if i*mb//ma<=10*n: ans=min(ans,dp[n][i][i*mb//ma])
if ans==INF: print((-1))
else: print(ans) | p03806 |
import fractions
n, ma, mb = list(map(int,input().split()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int,input().split()))
#iまでの薬品で、aがj(g),bがk(g)となるときの最小コスト
dp = [[[float('inf') for i in range(n + 1)] for j in range(401)] \
for k in range(401)]
dp[0][0][0] = 0
for i in range(1, n + 1):
for j in range(401):
for k in range(401):
# i番目を買うか、買わないか
if j < a[i] or k < b[i]:
dp[k][j][i] = dp[k][j][i - 1]
else:
dp[k][j][i] = min(dp[k][j][i - 1], \
dp[k - b[i]][j - a[i]][i - 1] + c[i])
i = 1
ans = float('inf')
while True:
if i * ma > 400 or i * mb > 400:
break
ans = min(ans, dp[i * mb][i * ma][n])
i += 1
if ans == float('inf'):
ans = -1
print(ans) | import fractions
n, ma, mb = list(map(int,input().split()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int,input().split()))
#iまでの薬品で、aがj(g),bがk(g)となるときの最小コスト
dp = [[[10**15 for i in range(n + 1)] for j in range(401)] \
for k in range(401)]
dp[0][0][0] = 0
sa = [0] * (n + 1)
sb = [0] * (n + 1)
for i in range(1, n + 1):
sa[i] = sa[i - 1] + a[i]
sb[i] = sb[i - 1] + b[i]
for i in range(1, n + 1):
for j in range(401):
if j > sa[i]:
break
for k in range(401):
if k > sb[i]:
break
# i番目を買うか、買わないか
if j < a[i] or k < b[i]:
dp[k][j][i] = dp[k][j][i - 1]
else:
dp[k][j][i] = min(dp[k][j][i - 1], \
dp[k - b[i]][j - a[i]][i - 1] + c[i])
i = 1
ans = 10 ** 15
while True:
if i * ma > 400 or i * mb > 400:
break
ans = min(ans, dp[i * mb][i * ma][n])
i += 1
if ans == 10 ** 15:
ans = -1
print(ans)
| p03806 |
import fractions
n, ma, mb = list(map(int,input().split()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int,input().split()))
#iまでの薬品で、aがj(g),bがk(g)となるときの最小コスト
dp = [[[10 ** 15 for i in range(n + 1)] for j in range(401)] \
for k in range(401)]
dp[0][0][0] = 0
sa = [0] * (n + 1)
sb = [0] * (n + 1)
for i in range(1, n + 1):
for j in range(401):
for k in range(401):
if j < a[i] or k < b[i]:
dp[k][j][i] = dp[k][j][i - 1]
else:
dp[k][j][i] = min(dp[k][j][i - 1], \
dp[k - b[i]][j - a[i]][i - 1] + c[i])
i = 1
ans = 10 ** 15
while True:
if i * ma > 400 or i * mb > 400:
break
ans = min(ans, dp[i * mb][i * ma][n])
i += 1
if ans == 10 ** 15:
ans = -1
print(ans)
"""
import fractions
n, ma, mb = map(int,input().split())
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = map(int,input().split())
#iまでの薬品で、aがj(g),bがk(g)となるときの最小コスト
dp = [[[10 ** 15 for i in range(n + 1)] for j in range(401)] \
for k in range(401)]
dp[0][0][0] = 0
sa = [0] * (n + 1)
sb = [0] * (n + 1)
for i in range(1, n + 1):
sa[i] = sa[i - 1] + a[i]
sb[i] = sb[i - 1] + b[i]
for i in range(1, n + 1):
for j in range(sa[i] + 1):
for k in range(sb[i] + 1):
if j < a[i] or k < b[i]:
dp[k][j][i] = dp[k][j][i - 1]
else:
dp[k][j][i] = min(dp[k][j][i - 1], \
dp[k - b[i]][j - a[i]][i - 1] + c[i])
i = 1
ans = 10 ** 15
while True:
if i * ma > 400 or i * mb > 400:
break
ans = min(ans, dp[i * mb][i * ma][n])
i += 1
if ans == 10 ** 15:
ans = -1
print(ans)
"""
| n, ma, mb = list(map(int,input().split()))
a = [0] * (n + 1)
b = [0] * (n + 1)
c = [0] * (n + 1)
for i in range(1, n + 1):
a[i], b[i], c[i] = list(map(int,input().split()))
#iまでの薬品で、aがj(g),bがk(g)となるときの最小コスト
dp = [[[10 ** 15 for i in range(n + 1)] for j in range(401)] \
for k in range(401)]
dp[0][0][0] = 0
sa = [0] * (n + 1)
sb = [0] * (n + 1)
for i in range(1, n + 1):
sa[i] = sa[i - 1] + a[i]
sb[i] = sb[i - 1] + b[i]
for i in range(1, n + 1):
for j in range(sa[i] + 1):
for k in range(sb[i] + 1):
if j < a[i] or k < b[i]:
dp[k][j][i] = dp[k][j][i - 1]
else:
dp[k][j][i] = min(dp[k][j][i - 1], \
dp[k - b[i]][j - a[i]][i - 1] + c[i])
i = 1
ans = 10 ** 15
while True:
if i * ma > 400 or i * mb > 400:
break
ans = min(ans, dp[i * mb][i * ma][n])
i += 1
if ans == 10 ** 15:
ans = -1
print(ans) | p03806 |
# coding:utf-8
import sys
# from collections import Counter, defaultdict
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
n, ma, mb = LI()
abc = [tuple(LI()) for _ in range(n)]
ab_max = n * 10 + 1
dp = [[[INF] * ab_max for _ in range(ab_max)] for _ in range(n + 1)]
dp[0][0][0] = 0
for i in range(n):
ai, bi, ci = abc[i]
for a in range(ab_max - ai):
for b in range(ab_max - bi):
if dp[i][a][b] == INF:
continue
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + ai][b + bi] = min(dp[i][a + ai][b + bi], dp[i][a][b] + ci)
ans = INF
c = 1
while True:
a, b = c * ma, c * mb
if a >= ab_max or b >= ab_max:
break
ans = min(ans, dp[n][a][b])
c += 1
print((ans if ans != INF else -1))
| # coding:utf-8
import sys
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
n, ma, mb = LI()
src = []
a_max, b_max = 1, 1
for _ in range(n):
a, b, c = LI()
src.append((a, b, c))
a_max += a
b_max += b
dp = [[[INF] * b_max for _ in range(a_max)] for _ in range(n + 1)]
dp[0][0][0] = 0
for i in range(n):
ai, bi, ci = src[i]
for a in range(a_max - ai):
for b in range(b_max - bi):
if dp[i][a][b] == INF:
continue
dp[i + 1][a][b] = min(dp[i + 1][a][b], dp[i][a][b])
dp[i + 1][a + ai][b + bi] = min(dp[i][a + ai][b + bi], dp[i][a][b] + ci)
ans = INF
c = 1
while True:
a, b = c * ma, c * mb
if a >= a_max or b >= b_max:
break
ans = min(ans, dp[n][a][b])
c += 1
print((ans if ans != INF else -1))
| p03806 |
N,Ma,Mb = list(map(int,input().split()))
INF = 10000
dp = [[[INF for b in range(401)] for a in range(401)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(1,N+1):
ai,bi,ci = list(map(int,input().split()))
for a in range(401):
for b in range(401):
if a-ai >= 0 and b-bi >= 0:
dp[i][a][b] = min(dp[i-1][a][b],dp[i-1][a-ai][b-bi]+ci)
else:
dp[i][a][b] = dp[i-1][a][b]
ans = INF
for j in range(1,401):
if Ma*j >= 400 or Mb*j >= 400:
break
ans = min(ans,dp[N][Ma*j][Mb*j])
print((ans if ans != INF else -1))
| N,Ma,Mb = list(map(int,input().split()))
INF = 10000
dp = [[INF for b in range(401)] for a in range(401)]
dp[0][0] = 0
for i in range(1,N+1):
ai,bi,ci = list(map(int,input().split()))
for a in range(400,-1,-1):
for b in range(400,-1,-1):
if a-ai >= 0 and b-bi >= 0:
dp[a][b] = min(dp[a][b],dp[a-ai][b-bi]+ci)
ans = INF
for j in range(1,401):
if Ma*j > 400 or Mb*j > 400:
break
ans = min(ans,dp[Ma*j][Mb*j])
print((ans if ans != INF else -1))
| p03806 |
N,Ma,Mb = list(map(int,input().split()))
INF = float('inf')
dp = [[INF for b in range(401)] for a in range(401)]
dp[0][0] = 0
for i in range(1,N+1):
ai,bi,ci = list(map(int,input().split()))
for a in range(400,-1,-1):
for b in range(400,-1,-1):
if a-ai >= 0 and b-bi >= 0:
dp[a][b] = min(dp[a][b],dp[a-ai][b-bi]+ci)
ans = INF
for j in range(1,401):
if Ma*j > 400 or Mb*j > 400:
break
ans = min(ans,dp[Ma*j][Mb*j])
print((ans if ans != INF else -1))
| N,Ma,Mb = list(map(int,input().split()))
INF = float('inf')
dp = [[INF for b in range(401)] for a in range(401)]
dp[0][0] = 0
sa = 0
sb = 0
for i in range(1,N+1):
ai,bi,ci = list(map(int,input().split()))
sa += ai
sb += bi
for a in range(sa+1,-1,-1):
for b in range(sb+1,-1,-1):
if a-ai >= 0 and b-bi >= 0:
dp[a][b] = min(dp[a][b],dp[a-ai][b-bi]+ci)
ans = INF
for j in range(1,401):
if Ma*j > 400 or Mb*j > 400:
break
ans = min(ans,dp[Ma*j][Mb*j])
print((ans if ans != INF else -1))
| p03806 |
N,MA,MB = list(map(int,input().split()))
src = []
sum_a = sum_b = 0
for i in range(N):
a,b,c = list(map(int,input().split()))
src.append((a,b,c))
sum_a += a
sum_b += b
INF = 10**9
dp = [[[INF for b in range(sum_b+1)] for a in range(sum_a+1)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
ai,bi,ci = src[i]
for a in range(sum_a+1 - ai):
for b in range(sum_b+1 - bi):
dp[i+1][a][b] = min(dp[i+1][a][b], dp[i][a][b])
dp[i+1][a+ai][b+bi] = min(dp[i][a+ai][b+bi], dp[i][a][b] + ci)
ans = INF
n = 1
while True:
a,b = n*MA,n*MB
if a > sum_a or b > sum_b: break
ans = min(ans, dp[N][a][b])
n += 1
print((ans if ans != INF else -1)) | N,MA,MB = list(map(int,input().split()))
src = []
sum_a = sum_b = 0
for i in range(N):
a,b,c = list(map(int,input().split()))
src.append((a,b,c))
sum_a += a
sum_b += b
INF = 10**9
dp = [[[INF for b in range(sum_b+1)] for a in range(sum_a+1)] for i in range(N+1)]
dp[0][0][0] = 0
for i in range(N):
ai,bi,ci = src[i]
for a in range(sum_a+1 - ai):
for b in range(sum_b+1 - bi):
if dp[i][a][b] == INF: continue
dp[i+1][a][b] = min(dp[i+1][a][b], dp[i][a][b])
dp[i+1][a+ai][b+bi] = min(dp[i][a+ai][b+bi], dp[i][a][b] + ci)
ans = INF
n = 1
while True:
a,b = n*MA,n*MB
if a > sum_a or b > sum_b: break
ans = min(ans, dp[N][a][b])
n += 1
print((ans if ans != INF else -1)) | p03806 |
N,MA,MB = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(N)]
INF = 10**9
dp = [[INF for j in range(401)] for i in range(401)]
dp[0][0] = 0
maxa = maxb = 0
for a,b,c in src:
for ai in range(maxa,-1,-1):
for bi in range(maxb,-1,-1):
dp[ai+a][bi+b] = min(dp[ai+a][bi+b], dp[ai][bi] + c)
maxa += a
maxb += b
ans = INF
for i in range(1,401):
if MA*i > 400 or MB*i > 400: break
ans = min(ans, dp[MA*i][MB*i])
print((-1 if ans == INF else ans)) | N,MA,MB = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(N)]
INF = 10**9
MAX = 401
dp = [[INF] * MAX for i in range(MAX)]
dp[0][0] = 0
amax = bmax = 0
for a,b,n in src:
for i in reversed(list(range(bmax+1))):
for j in range(amax+1):
if dp[i][j] == INF: continue
dp[i+b][j+a] = min(dp[i+b][j+a], dp[i][j] + n)
amax += a
bmax += b
ans = INF
for i in range(1,MAX):
if i*MA >= MAX or i*MB >= MAX: break
ans = min(ans, dp[i*MB][i*MA])
print((-1 if ans == INF else ans)) | p03806 |
N , Ma, Mb = list(map(int, input().split()))
a = [0] * N
b = [0] * N
c = [0] * N
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
# 最小値を求める問題なのでinfで初期化
# dp[i][sun_a][sum_b]で考えていく
dp = [[[float('inf') for _ in range(10 * N + 1)] for _ in range(10 * N + 1)] for _ in range(N+1)]
# 初期選択状態を0とする
dp[0][0][0] = 0
for i in range(N):
for j in range(10*N+1):
for k in range(10*N+1):
if dp[i][j][k] == float('inf'):
continue
# 選ばなかった場合
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])
ans = float('inf')
# 0スタートは何を選んでいない状態となり最小値が0になってしまうため1から開始する
# TLEになったため変更
#for i in range(1,10 * N + 1):
# for j in range(1,10 * N + 1):
# if i * Mb != j * Ma:
# continue
# ans = min(ans, dp[N][i][j])
#
for i in range(1, 10*N+1):
if i*Ma>10*N or i*Mb>10*N:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == float('inf'):
print((-1))
else:
print(ans) | N , Ma, Mb = list(map(int, input().split()))
a = [0] * N
b = [0] * N
c = [0] * N
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
# TLEになってしまうためinfを5000とかで設定する
INF = 5000
# 最小値を求める問題なのでinfで初期化
# dp[i][sun_a][sum_b]で考えていく
dp = [[[INF for _ in range(10 * N + 1)] for _ in range(10 * N + 1)] for _ in range(N+1)]
# 初期選択状態を0とする
dp[0][0][0] = 0
for i in range(N):
for j in range(10*N+1):
for k in range(10*N+1):
if dp[i][j][k] == INF:
continue
# 選ばなかった場合
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])
ans = INF
# 0スタートは何を選んでいない状態となり最小値が0になってしまうため1から開始する
# TLEになったため変更
#for i in range(1,10 * N + 1):
# for j in range(1,10 * N + 1):
# if i * Mb != j * Ma:
# continue
# ans = min(ans, dp[N][i][j])
#
for i in range(1, 10*N+1):
if i*Ma>10*N or i*Mb>10*N:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == INF:
print((-1))
else:
print(ans) | p03806 |
N , Ma, Mb = list(map(int, input().split()))
a = [0] * N
b = [0] * N
c = [0] * N
for i in range(N):
a[i], b[i], c[i] = list(map(int, input().split()))
# TLEになってしまうためinfを5000とかで設定する
INF = 5000
# さらに計算量を落とすため10 * N + 1などを定数で設定する
# 最小値を求める問題なのでinfで初期化
# dp[i][sun_a][sum_b]で考えていく
dp = [[[INF for _ in range(401)] for _ in range(401)] for _ in range(41)]
# 初期選択状態を0とする
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] == INF:
continue
# 選ばなかった場合
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])
ans = INF
# 0スタートは何を選んでいない状態となり最小値が0になってしまうため1から開始する
# TLEになったため変更
#for i in range(1,10 * N + 1):
# for j in range(1,10 * N + 1):
# if i * Mb != j * Ma:
# continue
# ans = min(ans, dp[N][i][j])
#
for i in range(1, 401):
if i*Ma>10*N or i*Mb>10*N:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == INF:
print((-1))
else:
print(ans) | N , Ma, Mb = list(map(int, input().split()))
# 入力値の受け取り方を変える
arr=[list(map(int,input().split())) for _ in range(N)]
#a = [0] * N
#b = [0] * N
#c = [0] * N
#for i in range(N):
# a[i], b[i], c[i] = map(int, input().split())
# TLEになってしまうためinfを5000とかで設定する
INF = 5000
# さらに計算量を落とすため10 * N + 1などを定数で設定する → 関係なかったため戻す
# 最小値を求める問題なのでinfで初期化
# dp[i][sun_a][sum_b]で考えていく
dp = [[[INF for _ in range(10 * N + 1)] for _ in range(10 * N + 1)] for _ in range(N+1)]
# 初期選択状態を0とする
dp[0][0][0] = 0
for i in range(N):
a,b,c=arr[i]
for j in range(10*N+1):
for k in range(10*N+1):
if dp[i][j][k] == INF:
continue
# 選ばなかった場合
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
# 選んだ場合
dp[i+1][j+a][k+b] = min(dp[i+1][j+a][k+b], dp[i][j][k] + c)
ans = INF
# 0スタートは何を選んでいない状態となり最小値が0になってしまうため1から開始する
# TLEになったため変更
#for i in range(1,10 * N + 1):
# for j in range(1,10 * N + 1):
# if i * Mb != j * Ma:
# continue
# ans = min(ans, dp[N][i][j])
#
for i in range(1, 10*N+1):
if i*Ma>10*N or i*Mb>10*N:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == INF:
print((-1))
else:
print(ans) | p03806 |
N,Ma,Mb = list(map(int, input().split()))
arr=[list(map(int,input().split())) for _ in range(N)]
dp=[[[5000]*401 for _ in range(401)] for _ in range(41)]
dp[0][0][0] = 0
for i in range(N):
a,b,c=arr[i]
for j in range(10*N+1):
for k in range(10*N+1):
if dp[i][j][k] == 5000:
continue
dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k])
dp[i+1][j+a][k+b]=min(dp[i+1][j+a][k+b],dp[i][j][k]+c)
ans=5000
for i in range(1,401):
if i*Ma>400 or i*Mb>400:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == 5000:
print((-1))
else:
print(ans) | def calc():
N,Ma,Mb = list(map(int, input().split()))
arr=[list(map(int,input().split())) for _ in range(N)]
dp=[[[5000]*401 for _ in range(401)] for _ in range(41)]
dp[0][0][0] = 0
for i in range(N):
a,b,c=arr[i]
for j in range(10*N+1):
for k in range(10*N+1):
if dp[i][j][k] == 5000:
continue
dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k])
dp[i+1][j+a][k+b]=min(dp[i+1][j+a][k+b],dp[i][j][k]+c)
ans=5000
for i in range(1,401):
if i*Ma>400 or i*Mb>400:
break
ans = min(ans, dp[N][i*Ma][i*Mb])
if ans == 5000:
print((-1))
else:
print(ans)
calc() | p03806 |
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, Ma, Mb = inpl()
INF = 4001
DP = [[INF]*(411) for _ in range(411)]
DP[0][0] = 0
for n in range(N):
DP2 = [[INF]*(411) for _ in range(411)]
a, b, c = inpl()
for i in range(10*(n+1) + 1):
for j in range(10*(n+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)) | # -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, Ma, Mb = inpl()
INF = 4001
DP = [[INF]*(411) for _ in range(411)]
DP[0][0] = 0
for n in range(N):
DP2 = [[INF]*(411) for _ in range(411)]
a, b, c = inpl()
for i in range(10*(n+1) + 1):
for j in range(10*(n+1) + 1):
if DP[i][j] == INF:
continue
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)) | p03806 |
N, Ma, Mb = list(map(int, input().split()))
INF = 10 ** 18
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 = list(map(int, input().split()))
for j in range(10*N+1-a):
for k in range(10*N+1-b):
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
dp[i+1][j+a][k+b] = min(dp[i+1][j+a][k+b], dp[i][j][k]+c)
ans = INF
for j in range(1, 10*N+1):
if j * Ma > 10 * N or j * Mb > 10 * N:
break
ans = min(ans, dp[N][j*Ma][j*Mb])
if ans == INF:
ans = -1
print(ans) | N, Ma, Mb = list(map(int, input().split()))
INF = 10 ** 18
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 = list(map(int, input().split()))
for j in range(10*N+1-a):
for k in range(10*N+1-b):
if dp[i][j][k] == INF:
continue
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
dp[i+1][j+a][k+b] = min(dp[i+1][j+a][k+b], dp[i][j][k]+c)
ans = INF
for j in range(1, 10*N+1):
if j * Ma > 10 * N or j * Mb > 10 * N:
break
ans = min(ans, dp[N][j*Ma][j*Mb])
if ans == INF:
ans = -1
print(ans) | p03806 |
n, ma, mb = list(map(int, input().split()))
abc = [tuple(int(x) for x in input().split()) for _ in range(n)]
c = n * 100 + 1
dp = [[[99999 for _ in range(1001)] for _ in range(1001)] for _ in range(n + 1)]
ans = 99999
dp[0][0][0] = 0
for i in range(n):
for j in range(1001):
for k in range(1001):
if dp[i][j][k] < 9999:
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
dp[i+1][j+abc[i][0]][k+abc[i][1]] = min(dp[i+1][j+abc[i][0]][k+abc[i][1]], dp[i][j][k] + abc[i][2])
if (j+abc[i][0]) * mb == (k+abc[i][1]) * ma:
ans = min(ans, dp[i+1][j+abc[i][0]][k+abc[i][1]])
if ans == 99999:
print((-1))
else:
print(ans) | n, ma, mb = list(map(int, input().split()))
abc = [tuple(int(x) for x in input().split()) for _ in range(n)]
c = n * 100 + 1
m = 401
dp = [[[99999 for _ in range(m)] for _ in range(m)] for _ in range(n + 1)]
ans = 99999
dp[0][0][0] = 0
for i in range(n):
for j in range(m):
for k in range(m):
if dp[i][j][k] < 9999:
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
dp[i+1][j+abc[i][0]][k+abc[i][1]] = min(dp[i+1][j+abc[i][0]][k+abc[i][1]], dp[i][j][k] + abc[i][2])
if (j+abc[i][0]) * mb == (k+abc[i][1]) * ma:
ans = min(ans, dp[i+1][j+abc[i][0]][k+abc[i][1]])
if ans == 99999:
print((-1))
else:
print(ans) | p03806 |
N,Ma,Mb=list(map(int,input().split()))
dp = [[10**18 for _ in range(401)] for _ in range(401)]
dp[0][0]=0
for i in range(N):
a,b,c=list(map(int,input().split()))
for ca in range(361, -1, -1):
for cb in range(361, -1, -1):
dp[ca+a][cb+b] = min(dp[ca+a][cb+b],dp[ca][cb]+c)
ans = 10**18
for i in range(1, 40):
if ans > dp[Ma * i][Mb * i]:
ans = dp[Ma * i][Mb * i]
if ans == 10**18:
print((-1))
else:
print(ans)
| N,Ma,Mb=list(map(int,input().split()))
dp = [[10**18 for _ in range(401)] for _ in range(401)]
dp[0][0]=0
for i in range(N):
a,b,c=list(map(int,input().split()))
for ca in range(i * 10, -1, -1):
for cb in range(i * 10, -1, -1):
dp[ca+a][cb+b] = min(dp[ca+a][cb+b],dp[ca][cb]+c)
ans = 10**18
for ca in range(401):
for cb in range(401):
if not ca*Mb == cb*Ma or ca == 0:
continue
if ans > dp[ca][cb]:
ans = dp[ca][cb]
if ans == 10**18:
print((-1))
else:
print(ans)
| p03806 |
N, A, B = list(map(int, input().split()))
X = [1<<20] * 8080
for _ in range(N):
a, b, c = list(map(int, input().split()))
t = A*b-B*a
X = [min(X[i], (0 if (i-t)%8080 == 0 else X[(i-t)%8080]) + c) for i in range(8080)]
print((-1 if X[0] > 1<<18 else X[0])) | N, A, B = list(map(int, input().split()))
X = [1<<20] * 4040
for _ in range(N):
a, b, c = list(map(int, input().split()))
t = A*b-B*a
X = [min(X[i], (0 if (i-t)%4040 == 0 else X[(i-t)%4040]) + c) for i in range(4040)]
print((-1 if X[0] > 1<<18 else X[0])) | p03806 |
n,ma,mb = list(map(int,input().split()))
INF = 10**4
dp = [[[INF] * (n*10+1) for _ in range(n*10+1)] for _ in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
a,b,c = list(map(int,input().split()))
for ai in range(n*10):
for bi in range(n*10):
if ai>=a and bi>=b:
tmp = dp[i][ai-a][bi-b] + c
else:
tmp = INF
dp[i+1][ai][bi] = min(dp[i][ai][bi], tmp)
ans = min(dp[n][ma*i][mb*i] for i in range(1,n*10//max(ma,mb)+1) )
if ans == INF: ans = -1
print(ans) | n,ma,mb = list(map(int,input().split()))
INF = 10**4
dp = [[[INF] * (n*10+1) for _ in range(n*10+1)] for _ in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
a,b,c = list(map(int,input().split()))
for ai in range(i*10+11):
for bi in range(i*10+11):
if ai>=a and bi>=b:
tmp = dp[i][ai-a][bi-b] + c
else:
tmp = INF
dp[i+1][ai][bi] = min(dp[i][ai][bi], tmp)
ans = min(dp[n][ma*i][mb*i] for i in range(1,n*10//max(ma,mb)+1) )
if ans == INF: ans = -1
print(ans) | p03806 |
N,Ma,Mb=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)
sa = sum(A)
sb = sum(B)
dp = [[[10000]*(sb+1) for _ in range(sa+1)] for _ in range(N+1)]
dp[0][0][0] = 0
ta = 0
tb = 0
for i in range(N):
a = A[i]
b = B[i]
for j in range(sa):
for k in range(sb):
if j - a >= 0 and k - b >= 0:
dp[i+1][j][k] = min(dp[i][j-a][k-b]+C[i], dp[i][j][k])
else:
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
dnp = dp[N]
ans = 10000
for i in range(sa):
for j in range(sb):
if Ma * (j+1) == Mb * (i+1):
ans = min(ans, dnp[i+1][j+1])
if ans == 10000:
ans = -1
print(ans) | N,Ma,Mb=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)
sa = sum(A)
sb = sum(B)
dp = [[[10000]*(sb+1) for _ in range(sa+1)] for _ in range(N+1)]
dp[0][0][0] = 0
ta = 0
tb = 0
for i in range(N):
a = A[i]
b = B[i]
for j in range(sa):
for k in range(sb):
if j - a >= 0 and k - b >= 0:
dp[i+1][j][k] = min(dp[i][j-a][k-b]+C[i], dp[i][j][k])
else:
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k])
ans = 10000
for i in range(1, sa+1):
for j in range(1, sb+1):
if Ma * j == Mb * i:
ans = min(ans, dp[N][i][j])
if ans == 10000:
ans = -1
print(ans) | p03806 |
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意
n,A,B = [int(i) for i in readline().split()]
abc = [[int(i) for i in readline().split()] for j in range(n)]
res1 = []
res2 = []
eq = 10**9
def dfs(s,g,amari,yen,List):
global eq
if s != g:
a,b,c = abc[s]
if a*B == A*b:
eq = min(eq,c)
dfs(s+1,g,amari,yen,List)
else:
dfs(s+1,g,amari+a*B-b*A,yen+c,List)
dfs(s+1,g,amari ,yen,List)
else:
if amari != 0:
List.append((amari,yen))
else:
if yen != 0:
eq = min(eq,yen)
dfs(0,n//2,0,0,res1)
dfs(n//2,n,0,0,res2)
#res1.sort()
res2.sort()
#print(res1)
#print(res2)
from bisect import *
ans = min(10**9,eq)
L = len(res2)
for amari,yen in res1:
i = bisect(res2,(-amari,-10000000))
if i < L and res2[i][0] == -amari:
if 0 < yen+res2[i][1] < ans:
ans = yen+res2[i][1]
if ans == 10**9:
print((-1))
else:
print(ans)
| # coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意
n,A,B = [int(i) for i in readline().split()]
abc = [[int(i) for i in readline().split()] for j in range(n)]
res1 = []
res2 = []
eq = 10**9
"""
def dfs(s,g,amari,yen,List):
global eq
if s != g:
a,b,c = abc[s]
if a*B == A*b:
eq = min(eq,c)
dfs(s+1,g,amari,yen,List)
else:
dfs(s+1,g,amari+a*B-b*A,yen+c,List)
dfs(s+1,g,amari ,yen,List)
else:
if amari != 0:
List.append((amari,yen))
else:
if yen != 0:
eq = min(eq,yen)
dfs(0,n//2,0,0,res1)
dfs(n//2,n,0,0,res2)
"""
def dp(s,g):
global eq
d = {0:0}
for i in range(s,g):
nd = {}
a,b,c = abc[i]
# if a*B == A*b:
# eq = min(eq,c)
# else:
for amari,yen in list(d.items()):
if amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
yen += c
amari += a*B-b*A
if amari == 0 and yen != 0:
eq = min(eq,yen)
elif amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
d = nd
# print(d,nd)
return list(d.items())
res1 = dp(0,n//2)
res2 = dp(n//2,n)
#res1.sort()
res2.sort()
#print(res1)
#print(res2)
#print(eq)
from bisect import *
ans = min(10**9,eq)
L = len(res2)
for amari,yen in res1:
i = bisect(res2,(-amari,-10000000))
if i < L and res2[i][0] == -amari:
if 0 < yen+res2[i][1] < ans:
ans = yen+res2[i][1]
if ans == 10**9:
print((-1))
else:
print(ans)
| p03806 |
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意
n,A,B = [int(i) for i in readline().split()]
abc = [[int(i) for i in readline().split()] for j in range(n)]
res1 = []
res2 = []
eq = 10**9
"""
def dfs(s,g,amari,yen,List):
global eq
if s != g:
a,b,c = abc[s]
if a*B == A*b:
eq = min(eq,c)
dfs(s+1,g,amari,yen,List)
else:
dfs(s+1,g,amari+a*B-b*A,yen+c,List)
dfs(s+1,g,amari ,yen,List)
else:
if amari != 0:
List.append((amari,yen))
else:
if yen != 0:
eq = min(eq,yen)
dfs(0,n//2,0,0,res1)
dfs(n//2,n,0,0,res2)
"""
def dp(s,g):
global eq
d = {0:0}
for i in range(s,g):
nd = {}
a,b,c = abc[i]
# if a*B == A*b:
# eq = min(eq,c)
# else:
for amari,yen in list(d.items()):
if amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
yen += c
amari += a*B-b*A
if amari == 0 and yen != 0:
eq = min(eq,yen)
elif amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
d = nd
# print(d,nd)
return list(d.items())
res1 = dp(0,n//2)
res2 = dp(n//2,n)
#res1.sort()
res2.sort()
#print(res1)
#print(res2)
#print(eq)
from bisect import *
ans = min(10**9,eq)
L = len(res2)
for amari,yen in res1:
i = bisect(res2,(-amari,-10000000))
if i < L and res2[i][0] == -amari:
if 0 < yen+res2[i][1] < ans:
ans = yen+res2[i][1]
if ans == 10**9:
print((-1))
else:
print(ans)
| # coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意
n,A,B = [int(i) for i in readline().split()]
abc = [[int(i) for i in readline().split()] for j in range(n)]
ans = 10**9
d = {0:0}
for i in range(n):
nd = {}
a,b,c = abc[i]
for amari,yen in list(d.items()):
if amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
yen += c
amari += a*B-b*A
if amari == 0 and yen != 0:
ans = min(ans,yen)
elif amari in nd:
nd[amari] = min(nd[amari],yen)
else:
nd[amari] = yen
d = nd
# print(d,nd)
if ans == 10**9:
print((-1))
else:
print(ans)
| p03806 |
n,ma,mb=list(map(int,input().split()))
dp=[[0]*401 for _ in range(401)]
for _ in range(n):
a,b,c=list(map(int,input().split()))
for i in range(400,-1,-1):
for j in range(400,-1,-1):
if i-a<0 or j-b<0:
continue
else:
if dp[i-a][j-b]==0:
continue
else:
if dp[i][j]==0:
dp[i][j]=dp[i-a][j-b]+c
else:
dp[i][j]=min(dp[i][j],dp[i-a][j-b]+c)
if dp[a][b]==0:
dp[a][b]=c
else:
dp[a][b]=min(dp[a][b],c)
ans=10**10
for i in range(401):
if i*ma>400 or i*mb>400:
break
if dp[i*ma][i*mb]==0:
continue
else:
ans=min(ans,dp[i*ma][i*mb])
if ans==10**10:
print((-1))
else:
print(ans)
| import sys
n, ma, mb = list(map(int, input().split()))
abc = []
for _ in range(n):
a, b, cost = list(map(int, input().split()))
abc.append((a, b, cost))
def main():
sa = 0
sb = 0
for i in range(n):
sa += abc[i][0]
sb += abc[i][1]
res = [[float('infinity')] * (sb + 1) for _ in range(sa + 1)]
res[0][0] = 0
for a, b, c in abc:
for j in range(sa, -1, -1):
for k in range(sb, -1, -1):
if j >= a and k >= b:
res[j][k] = min(res[j][k], res[j-a][k-b] + c)
ans = float('infinity')
for i in range(1, min(sa//ma, sb//mb) + 1):
ans = min(ans, res[ma*i][mb*i])
if ans == float('infinity'):
return -1
else:
return ans
if __name__ == '__main__':
ans = main()
print(ans) | p03806 |
from copy import deepcopy
N, MA, MB = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
DP = [[100000 for _ in range(401)] for _ in range(401)]
DP[0][0] = 0
S = {(0, 0)}
for a, b, c in X:
DP2 = deepcopy(DP)
for sa, sb in S:
if DP[sa+a][sb+b] > DP2[sa][sb] + c:
DP[sa+a][sb+b] = DP2[sa][sb] + c
T = {(sa+a, sb+b) for sa, sb in S}
S |= T
a, b = MA, MB
ans = 100000
while a <= 400 and b <= 400:
ans = min(ans, DP[a][b])
a += MA
b += MB
if ans == 100000:
print(-1)
else:
print(ans)
| from collections import defaultdict
N, MA, MB = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
dp = defaultdict()
dp[(0, 0)] = 0
for a, b, c in X:
dp2 = defaultdict()
for sa, sb in dp:
if (sa+a, sb+b) not in dp:
dp2[(sa+a, sb+b)] = dp[(sa, sb)] + c
elif dp[(sa+a, sb+b)] > dp[(sa, sb)] + c:
dp2[(sa+a, sb+b)] = dp[(sa, sb)] + c
for (na, nb) in dp2:
dp[(na, nb)] = dp2[(na, nb)]
a, b = MA, MB
ans = 100000
while a <= 400 and b <= 400:
if (a, b) in dp:
ans = min(ans, dp[(a, b)])
a += MA
b += MB
if ans == 100000:
print(-1)
else:
print(ans)
| p03806 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.