input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
dp=[0]*100
dp[0],dp[1]=2,1
for i in range(90):
dp[i+2]=dp[i]+dp[i+1]
print((dp[int(eval(input()))]))
|
n=int(eval(input()))
dp=[0]*100
dp[0]=2
dp[1]=1
for i in range(90):
dp[i+2]=dp[i]+dp[i+1]
print((dp[n]))
|
p03544
|
N = int(eval(input()))
R = [None] * (N+1)
R[0] = 2
if N == 0:
print((R[0]))
exit()
R[1] =1
if N == 1:
print((R[1]))
exit()
if N >= 2:
for i in range(2, N+1):
R[i] = R[i-1] + R[i-2]
print((R[N]))
|
N = int(eval(input()))
R = [2, 1]
if N < 2:
print((R[N]))
exit()
for i in range(2, N+1):
R.append(R[i-1] + R[i-2])
print((R[N]))
|
p03544
|
n = int(eval(input()))
a, b = 2, 1
for _ in range(n):
a, b = b, a+b
print(a)
|
a,b = 2,1
n = int(eval(input()))
for _ in range(n-1):
a,b = b,a+b
print(b)
|
p03544
|
n = int(eval(input()))
l = [2,1]
for i in range(n+1):
l.append(l[i]+l[i+1])
print((l[n]))
|
n = int(eval(input()))
a = [2,1]
for i in range(2,n+2):
a.append(a[i-1]+a[i-2])
print((a[n]))
|
p03544
|
from functools import lru_cache
N = int(eval(input()))
@lru_cache(maxsize=None)
def luca(n):
if n == 0:
return 2
if n == 1:
return 1
return luca(n - 1) + luca(n - 2)
print((luca(N)))
|
n = int(eval(input()))
luca = [0]*(n+1)
luca[0] = 2
luca[1] = 1
for i in range(2, n+1):
luca[i] = luca[i-1] + luca[i-2]
print((luca[n]))
|
p03544
|
a = int(eval(input()))
b = [2, 1]
for i in range(2, a+1):
b.append(b[i-1]+b[i-2])
print((b[a]))
|
a = int(eval(input()))
b = [2, 1]
for i in range(1, a):
b.append(b[i] + b[i-1])
print((b[len(b)-1]))
|
p03544
|
a,b=2,1
for i in range(int(eval(input()))):a,b=b,a+b
print(a)
|
N=int(eval(input()))
a,b=2,1
for i in range(N):
a,b=b,a+b
print(a)
|
p03544
|
N = int(eval(input()))
l = [2,1]
i = 2
while len(l)<N+1:
l.append(l[i-1]+l[i-2])
i+=1
print((l[N]))
|
n = int(eval(input()))
l = [0]*100
l[0] = 2
l[1] = 1
for i in range(2,100):
l[i] = l[i-1] + l[i-2]
print((l[n]))
|
p03544
|
N = int(eval(input()))
L = [0]*(N+1)
L[0],L[1]=2,1
for i in range(2,N+1):
L[i] = L[i-1]+L[i-2]
print((L[N]))
|
def solve():
ans = 0
N = int(eval(input()))
dp = [0]*(N+1)
dp[0]=2
dp[1]=1
for i in range(2,N+1):
dp[i] = dp[i-1]+dp[i-2]
return dp[-1]
print((solve()))
|
p03544
|
n = int(eval(input()))
cnt = 1
l = [2, 1]
while True:
cnt += 1
l.append(l[len(l)-1] + l[len(l)-2])
if cnt == n:
print((l[len(l) - 1]))
exit()
|
n = int(eval(input()))
cnt = 1
l = [2, 1]
if n == 0:
print((2))
elif n == 1:
print((1))
else:
while True:
cnt += 1
l.append(l[len(l)-1] + l[len(l)-2])
if cnt == n:
print((l[len(l) - 1]))
exit()
|
p03544
|
a = int(eval(input()))
b = []
for i in range(a+1):
if i==0:
b.append(2)
elif i==1:
b.append(1)
else:
b.append(b[i-2]+b[i-1])
else:
print((b[a]))
|
N = int(eval(input()))
L = [2,1]
for i in range(2,N+1):
L.append(L[i-2]+L[i-1])
print((L[N]))
|
p03544
|
n = int(eval(input()))
ans = 0
l = [2, 1]
for i in range(n-1):
l.append(l[i]+l[i+1])
print((l[n]))
|
n = int(eval(input()))
l = [2, 1]
for i in range(n-1):
l.append(l[i]+l[i+1])
print((l[n]))
|
p03544
|
N=int(eval(input()))
lst=[2,1]
for i in range(2,N+1):
lst.append(lst[i-1]+lst[i-2])
print((lst[N]))
|
N=int(eval(input()))
lucas=[2,1]
for i in range(2,N+1):
lucas.append(lucas[i-1]+lucas[i-2])
print((lucas[N]))
|
p03544
|
N = int(eval(input()))
L = [0] * 87
L[0], L[1] = 2, 1
for i in range(2, N+1):
L[i] = L[i-1] + L[i-2]
print((L[N]))
|
N = int(eval(input()))
L = [2, 1]
for i in range(2, N+1):
L.append(L[i-1]+L[i-2])
print((L[N]))
|
p03544
|
N = int(eval(input()))
L = [0] * 87
L[0] = 2
L[1] = 1
for i in range(2, len(L)):
L[i] = L[i - 1] + L[i - 2]
print((L[N]))
|
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
L = [-1] * 100
L[0] = 2
L[1] = 1
for i in range(2, 100):
L[i] = L[i - 1] + L[i - 2]
# print('L', L)
print((L[N]))
|
p03544
|
N = int(eval(input()))
ans = [2,1]
for i in range(2,87):
ans.append(ans[i-1] + ans[i-2])
print((ans[N]))
|
N = int(eval(input()))
lucas = [0]*(N+1)
lucas[0] = 2
lucas[1] = 1
for i in range(N-1):
lucas[i+2] = lucas[i+1] + lucas[i]
print((lucas[N]))
|
p03544
|
n = int(eval(input()))
l = [2, 1]
for i in range(2, n + 1):
l.append(l[i - 2] + l[i - 1])
print((l[n]))
|
n = int(eval(input()))
if n == 1:
print((1))
else:
Li = 2
Lj = 1
cnt = 2
while True:
Lk = Li + Lj
if cnt == n:
print(Lk)
break
cnt += 1
Li = Lj
Lj = Lk
|
p03544
|
from itertools import combinations
D, G = list(map(int, input().split()))
PC = []
for i in range(D):
p, c = list(map(int, input().split()))
total = ((i + 1) * 100) * p + c
PC.append([p, c, total])
A = []
B = {i for i in range(D)}
for i in range(D+1):
A += list(combinations(B, i))
# print(A)
ans = []
for ai in A:
p = 0 # ポイント
c = 0 # 問題数
for aii in ai:
p += PC[aii][2]
c += PC[aii][0]
if p < G:
x = B.difference(ai)
max_x = max(x)
cnt = 0
while p < G and cnt < PC[max_x][0] - 1:
p += (max_x + 1) * 100
cnt += 1
c += 1
if p >= G:
# ans.append([p, c])
ans.append(c)
else:
# ans.append([p, c])
ans.append(c)
print((min(ans)))
|
D, G = list(map(int, input().split()))
PC = []
for i in range(D):
p, c = list(map(int, input().split()))
s = (i+1) * 100
PC.append([p, c, s])
P = []
for i in range(2 ** D):
b = format(i, 'b').zfill(D)
P.append(b)
def get_high_score_q(p):
if p.count('0') == 0:
return None
else:
pos = []
for i, pi in enumerate(p):
if pi == '0':
pos.append(i)
return pos[-1]
ans = 10 ** 10
# P: ['00', '01', '10', '11']
for pi in P:
# print('pi', pi)
scores = 0
probs = 0
for i, b in enumerate(pi):
if b == '0':
pass
elif b == '1':
pc = PC[i]
scores += pc[0] * pc[2] + pc[1]
probs += pc[0]
else:
raise Exception()
# print(scores, probs)
if scores < G:
q = get_high_score_q(pi)
pc = PC[q]
for i in range(pc[0]):
scores += pc[2]
probs += 1
if scores >= G:
break
# print(scores, probs)
if scores >= G:
ans = min(ans, probs)
print(ans)
|
p03290
|
d,g = list(map(int,input().split()))
a = [list(map(int,input().split())) for _ in range(d)]
s = set(range(d))
ans = float("Inf")
x = []
for i in zip(*a):
x.append(list(i))
c = []
for i in range(2**d):
b = []
for j in range(d):
if i>>j & 1:
b.append(j)
c.append(b)
for i in c:
d = 0
count = 0
for j in i:
d += (100*(j+1)) * a[j][0] + a[j][1]
count += a[j][0]
if d < g:
for x in sorted(s - set(i),reverse=True):
for y in range(a[x][0]):
if d >= g:
break
d += 100*(x+1)
count += 1
if d < g:continue
ans = min(ans,count)
print(ans)
|
d,g = list(map(int,input().split()))
ary = [list(map(int,input().split())) for _ in range(d)]
s = set(i for i in range(d))
ans = float("Inf")
for i in range(2**d):
a = []
total,count = 0,0
for j in range(d):
if i >> j & 1:
a.append(j)
for x in a:
total += 100*(x+1)*ary[x][0]+ary[x][1]
count += ary[x][0]
if total >= g:
ans = min(ans,count)
continue
for y in sorted(s - set(a),reverse=True):
if total + 100*(y+1)*(ary[y][0]-1) >= g:
count += -(-(g-total) // (100*(y+1)))
ans = min(ans,count)
break
total += 100*(y+1)*(ary[y][0]-1)
count += ary[y][0]-1
if total >= g:
ans = min(ans,count)
print(ans)
|
p03290
|
import copy
from typing import List, Tuple
def main():
d, g = list(map(int, input().split()))
v = []
for _ in range(d):
p, c = list(map(int, input().split()))
v.append((p, c))
print((ag(v, g)))
def ag(v: List[Tuple[int, int]], g: int) -> int:
# ex. [(3, 500), (5, 800)] -> [(1, 3, 500), (2, 5, 800)]
v = [(i, p, c) for i, (p, c) in enumerate(v, 1)]
result = 100 ** 10
for j in range(2 ** len(v)):
cb = []
for k in range(len(v)):
if ((j >> k) & 1):
cb.append(v[k])
sc = 0
cnt = 0
# calc bonus score
for (i, p, c) in cb:
sc += i * 100 * p + c
cnt += p
for idx in reversed(list(range(len(v)))):
if sc >= g:
break
if v[idx] in cb:
continue
i, p, _ = v[idx]
for _ in range(p - 1):
if sc >= g:
break
sc += i * 100
cnt += 1
if sc >= g:
result = min(result, cnt)
return result
if __name__ == '__main__':
main()
|
import itertools
from typing import List, Tuple
def main():
d, g = list(map(int, input().split()))
v = []
for _ in range(d):
p, c = list(map(int, input().split()))
v.append((p, c))
print((ag(v, g)))
def ag(v: List[Tuple[int, int]], g: int) -> int:
# ex. [(3, 500), (5, 800)] -> [(1, 3, 500), (2, 5, 800)]
v = [(i + 1, v[i][0], v[i][1]) for i in range(len(v))]
result = 100 ** 10
for j in range(len(v) + 1):
for cb in itertools.combinations(v, j):
sc = 0
cnt = 0
# calc bonus score
for (i, p, c) in cb:
sc += i * 100 * p + c
cnt += p
for idx in reversed(list(range(len(v)))):
if sc >= g:
break
if v[idx] in cb:
continue
i, p, _ = v[idx]
for _ in range(p - 1):
if sc >= g:
break
sc += i * 100
cnt += 1
if sc >= g:
result = min(result, cnt)
return result
if __name__ == '__main__':
main()
|
p03290
|
# n, m, l = map(int, input().split())
# list_n = list(map(int, input().split()))
# n = input()
# list = [input() for i in range(N)
# list = [[i for i in range(N)] for _ in range(M)]
import math
import sys
input = sys.stdin.readline
D, G = list(map(int, input().split()))
# print(D, G)
P = []
C = []
for i in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
INF = 10**15
def F(i, n, GetPoint):
if i == D:
if GetPoint >= G:
return n, GetPoint
else:
return INF, INF
PerPoint = (i+1)*100
if GetPoint < G:
temp = INF, INF
for j in range(P[i]+1):
if j != P[i]:
N, GP = F(i+1, n+j, GetPoint+j*PerPoint)
else:
N, GP = F(i+1, n+j, GetPoint+j*PerPoint + C[i])
if N < temp[0]:
temp = N, GP
return temp
else:
return n, GetPoint
print((F(0, 0, 0)[0]))
|
# n, m, l = map(int, input().split())
# list_n = list(map(int, input().split()))
# n = input()
# list = [input() for i in range(N)
# list = [[i for i in range(N)] for _ in range(M)]
import math
import sys
input = sys.stdin.readline
D, G = list(map(int, input().split()))
# print(D, G)
P = []
C = []
for i in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
INF = 10**15
def F(i, n, GetPoint):
if i == D:
if GetPoint >= G:
return n, GetPoint
else:
return INF, INF
PerPoint = (i+1)*100
if GetPoint < G:
ANS = INF, INF
# ALL
N, GP = F(i+1, n+P[i], GetPoint+PerPoint*P[i] + C[i])
if N < ANS[0]:
ANS = N, GP
# through
N, GP = F(i+1, n, GetPoint)
if N < ANS[0]:
ANS = N, GP
# part
# 上位合計
PupperAll = sum([(j+1)*100*P[j] + C[j] for j in range(i+1, D)])
rN = math.ceil((G - GetPoint - PupperAll)/PerPoint)
if 0 < rN < P[i]:
GP = GetPoint + PerPoint*rN + PupperAll
N = n + rN + sum(P[i+1:])
if N < ANS[0]:
ANS = N, GP
return ANS
else:
return n, GetPoint
print((F(0, 0, 0)[0]))
|
p03290
|
ans = float("inf")
def solve():
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
# まだ解いてない配点を nokori として持つ
def dfs(i, sum, count, nokori):
global ans
if i == d:
# G 点に満たなければ nokori のうち一番大きいものを解く
if sum < g:
use = max(nokori)
# 解く問題が問題数を超えないように注意
n = min(pc[use - 1][0], -(-(g - sum) // (use * 100)))
count += n
sum += n * use * 100
if sum >= g:
ans = min(ans, count)
else:
# 総合スコア、解いた問題数、まだ解いてない問題を更新
dfs(i + 1, sum, count, nokori)
dfs(i + 1, sum + pc[i][0] * (i + 1) * 100 +
pc[i][1], count + pc[i][0], nokori - {i + 1})
dfs(0, 0, 0, set(range(1, d + 1)))
print(ans)
if __name__ == "__main__":
solve()
|
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
# まだ解いてない配点を nokori として持つ
ans = float("inf")
def dfs(i, sum, count, nokori):
global ans
if i == d:
# G 点に満たなければ nokori のうち一番大きいものを解く
if sum < g:
use = max(nokori)
# 解く問題が問題数を超えないように注意
n = min(pc[use - 1][0], -(-(g - sum) // (use * 100)))
count += n
sum += n * use * 100
if sum >= g:
ans = min(ans, count)
else:
# 総合スコア、解いた問題数、まだ解いてない問題を更新
dfs(i + 1, sum, count, nokori)
dfs(i + 1, sum + pc[i][0] * (i + 1) * 100 +
pc[i][1], count + pc[i][0], nokori - {i + 1})
dfs(0, 0, 0, set(range(1, d + 1)))
print(ans)
|
p03290
|
D,G = list(map(int,input().split()))
X = [list(map(int,input().split())) for _ in range(D)]
ans = 0
for i in range(2**D):
point = 0
count = 0
for j in range(D):
if (i>>j)&1:
point += 100*(j+1)*X[j][0]+X[j][1]
count += X[j][0]
if G > point:
for k in range(D)[::-1]:
if (i>>k)&1==0:
if (G-point) <= 100*(k+1)*(X[k][0]-1):
count += -((-(G-point)) // (100*(k+1)))
break
else:
count = 10**5
break
if ans == 0 or count < ans:
ans = count
print(ans)
|
D,G = list(map(int,input().split()))
X = [list(map(int,input().split())) for _ in range(D)]
ans = 0
for i in range(2**D):
point = 0
count = 0
for j in range(D):
if (i>>j)&1:
point += 100*(j+1)*X[j][0]+X[j][1]
count += X[j][0]
if G > point:
for k in range(D)[::-1]:
if (i>>k)&1==0:
if (G-point) <= 100*(k+1)*(X[k][0]):
count += (G-point-1) // (100*(k+1)) +1
break
else:
count = 10**5
break
if ans == 0 or count < ans:
ans = count
print(ans)
|
p03290
|
from itertools import product
def main():
d, g = list(map(int, input().split()))
score_set = []
score_set_qnum = []
for i1 in range(1, d + 1):
kazu, bonus = list(map(int, input().split()))
score_p = []
for i2 in range(kazu):
score_p.append(i1 * 100 * i2)
score_p.append(i1 * 100 * kazu + bonus)
score_set.append(score_p)
score_set_qnum.append(list(range(kazu + 1)))
score_set_pat = tuple(product(*score_set))
score_set_qnum_pat = tuple(product(*score_set_qnum))
inf = float('inf')
r = inf
for sset, ssetq in zip(score_set_pat, score_set_qnum_pat):
sset_sum = sum(sset)
if sset_sum >= g:
r = min(r, sum(ssetq))
print(r)
if __name__ == '__main__':
main()
|
from itertools import product
from math import ceil
def main():
d, g = list(map(int, input().split()))
scoremax_set = []
numq_set = []
for i1 in range(1, d + 1):
kazu, bonus = list(map(int, input().split()))
scoremax_set.append(i1 * 100 * kazu + bonus)
numq_set.append(kazu)
score_get_pat = tuple(product((1,0), repeat=d))
inf = float('inf')
r = inf
for sgpe in score_get_pat:
score = 0
q_num = 0
for j1, s in zip(sgpe, scoremax_set):
score += j1 * s
for j2, num in zip(sgpe, numq_set):
q_num += j2 * num
if score >= g:
r = min(r, q_num)
else:
sgpe_l = [i for i, x in enumerate(sgpe) if x == 0]
score_plus = (sgpe_l[-1]+1)*100 * (numq_set[sgpe_l[-1]] - 1)
if score + score_plus >= g:
q_num += ceil((g - score) / ((sgpe_l[-1]+1)*100))
r = min(r, q_num)
print(r)
if __name__ == '__main__':
main()
|
p03290
|
n,k = list(map(int,input().split()))
l = []
for i in range(n):
array = list(map(int,input().split()))
line = [int(j)*100*(i+1) for j in range(array[0])]
line.append(array[0]*100*(i+1)+array[1])
l.append(line)
chk = []
def f(a,b,c):
if a==n:
if b>=k:
chk.append(c)
return
else:
return [f(a+1,b+l[a][i],c+i) for i in range(len(l[a]))]
f(0,0,0)
print((min(chk)))
|
n,k = list(map(int,input().split()))
l = []
for i in range(n):
array = list(map(int,input().split()))
l_append=l.append
l_append(array)
chk = []
chk_append=chk.append
def f(a,b,c):
if a==n:
if b>=k:
chk_append(c)
return
else:
return [f(a+1,b+100*(a+1)*i,c+i) for i in range(l[a][0])] and f(a+1,b+100*(a+1)*(l[a][0])+l[a][1],c+l[a][0])
f(0,0,0)
print((min(chk)))
|
p03290
|
### ABC104C - All Green
from itertools import permutations
def main():
D, G = list(map(int, input().split()))
A = [(0, 0)] + [tuple(map(int, input().split())) for _ in range(D)]
ans = float("inf")
for perm in permutations(list(range(1, D + 1)), D):
cur, cnt = G, 0
for i in perm:
point, (num, bonus) = i * 100, A[i]
if cur / point < num:
cnt += cur // point
cur -= point * (cur // point)
else:
cnt += num
cur -= point * num + bonus
if cur <= 0:
ans = min(ans, cnt)
break
print(ans)
if __name__ == "__main__":
main()
|
### ABC104C - All Green
def rec(score: int, idx: int) -> int:
if idx == 0:
return float("inf")
point, (num, bonus) = idx * 100, A[idx]
cnt = min(score // point, num)
cur_score = cnt * point + bonus if cnt == num else cnt * point
rest = score - cur_score
if rest > 0:
cnt += rec(rest, idx - 1)
return min(cnt, rec(score, idx - 1))
def main():
global A
D, G = list(map(int, input().split()))
A = [(0, 0)] + [tuple(map(int, input().split())) for _ in range(D)]
ans = rec(G, D)
print(ans)
if __name__ == "__main__":
main()
|
p03290
|
import sys
sys.setrecursionlimit(2000)
D, goal = list(map(int, input().split()))
q_num, bonus = [], []
for i in range(1,D+1):
q, b = list(map(int, input().split()))
q_num.append(q)
bonus.append(b)
ans = 100000
def rec(comb, next_n, current_score):
if next_n == D + 1:
global ans
if current_score >= goal:
ans = min(ans, sum(comb))
else:
for i in range(q_num[next_n-1]):
rec(comb + [i], next_n+1, current_score + i * next_n * 100)
rec(comb + [q_num[next_n-1]], next_n+1, current_score + q_num[next_n-1] * next_n * 100 + bonus[next_n-1])
rec([], 1, 0)
print(ans)
|
import sys
sys.setrecursionlimit(2000)
D, goal = list(map(int, input().split()))
q_num, bonus = [], []
for i in range(1,D+1):
q, b = list(map(int, input().split()))
q_num.append(q)
bonus.append(b)
ans = 100000
def rec2(current_qn, next_n, current_score, tyuuto_done):
if next_n == D + 1:
global ans
if current_score >= goal:
ans = min(ans, current_qn)
else:
rec2(current_qn+q_num[next_n-1], next_n+1, current_score+q_num[next_n-1]*next_n*100+bonus[next_n-1], tyuuto_done)
rec2(current_qn, next_n+1, current_score, tyuuto_done)
if not tyuuto_done:
for i in range(1,q_num[next_n-1]):
rec2(current_qn+i, next_n+1, current_score+i*next_n*100, 1)
def rec(comb, next_n, current_score):
if next_n == D + 1:
global ans
if current_score >= goal:
ans = min(ans, sum(comb))
else:
for i in range(q_num[next_n-1]):
rec(comb + [i], next_n+1, current_score + i * next_n * 100)
rec(comb + [q_num[next_n-1]], next_n+1, current_score + q_num[next_n-1] * next_n * 100 + bonus[next_n-1])
# rec([], 1, 0)
rec2(0, 1, 0, 0)
print(ans)
|
p03290
|
d, g = list(map(int, input().split()))
test = []
point = []
for i in range(1, d+1):
p, c = list(map(int, input().split()))
test.append([p, c])
point.append([c + (p * i * 100), p])
inf = 10 ** 9
ans = inf
for i in range(2 ** d):
b = bin(i)[2:]
b = (d - len(b)) * "0" + b
temp = 0
calc = 0
for j, bb in enumerate(b):
if bb == "1":
calc += point[j][0]
temp += point[j][1]
if calc >= g:
ans = min(ans, temp)
else:
j_temp = b.rfind("0")
if (g - calc) <= (test[j_temp][0] - 1) * (j_temp + 1) * 100:
if (g - calc) % ((j_temp + 1) * 100) == 0:
ans = min(ans, temp + ((g - calc) // ((j_temp + 1) * 100)))
else:
ans = min(ans, temp + ((g - calc) // ((j_temp + 1) * 100)) + 1)
print(ans)
|
d, g = list(map(int, input().split()))
point = []
for i in range(d):
p, c = list(map(int, input().split()))
point.append([p, c])
def f(g, i):
if i == -1:
return 10000000
n = min(g // ((i + 1) * 100), point[i][0])
s = n * (i + 1) * 100
if n == point[i][0]:
s += point[i][1]
if s < g:
n += f(g - s, i - 1)
return min(n, f(g, i - 1))
print((f(g, d-1)))
|
p03290
|
def main():
D, G = list(map(int, input().split()))
A = []
for i in range(D):
p, c = list(map(int, input().split()))
A.append([i, p, c])
A = A[::-1]
cur = [[0, 0]]
used = [set()]
for i, p, c in A:
temp = []
temp_used = []
for j in range(len(cur)):
temp.append(cur[j])
temp_used.append(used[j])
temp.append([cur[j][0]+ 100*(i+1)*p+c, cur[j][1] + p])
temp_used.append(used[j] | {i})
cur = temp
used = temp_used
#
# print(cur)
# print(used)
ans = float('inf')
for j in range(len(cur)):
if cur[j][0] >= G:
ans = min(ans, cur[j][1])
else:
for i, p, c in A:
if i not in used[j]:
if cur[j][0] + 100 * (i+1) * (p-1) < G:
cur[j][0] += 100 * (i+1) * (p-1)
cur[j][1] += p-1
else:
if (G - cur[j][0]) % (100*(i+1)) == 0:
ans = min(ans, cur[j][1] + (G - cur[j][0]) // (100*(i+1)))
else:
ans = min(ans, cur[j][1] + (G - cur[j][0]) // (100*(i+1)) + 1)
break
return ans
if __name__ == '__main__':
print((main()))
|
def main():
D, G = list(map(int, input().split()))
A = []
for i in range(D):
p, c = list(map(int, input().split()))
A.append([i, p, c])
A = A[::-1]
hs = [[0, 0, 0]]
for i, p, c in A:
temp = []
for h, v, q in hs: temp.append([h|(1 << i), v+100*(i+1)*p+c, q+p])
hs += temp
# print(hs)
ans = float('inf')
for h, v, q in hs:
if v >= G:
ans = min(ans, q)
else:
for i, p, c in A:
if (h >> i) % 2 == 0:
if v + 100*(i+1)*(p-1) < G:
v += 100*(i+1)*(p-1)
q += p-1
else:
if (G-v) % (100*(i+1)) == 0:
ans = min(ans, q + (G-v) // (100*(i+1)))
else:
ans = min(ans, q + 1 + (G-v) // (100*(i+1)))
break
return ans
if __name__ == '__main__':
print((main()))
|
p03290
|
import math
D,G = list(map(int,input().split()))
p = []
c = []
for i in range(D):
p_tmp,c_tmp = list(map(int,input().split()))
p.append(p_tmp)
c.append(c_tmp)
ans = sum(p)
for i in range(D):
for j in range(p[i]):
for k in range(2**D-1):
score = (i+1)*100*j
ans_tmp = j
for l in range(D):
if l == i:
continue
elif (k>>l)%2 == 1:
score += (l+1)*100*p[l]+c[l]
ans_tmp += p[l]
if score >= G:
ans = min(ans,ans_tmp)
print(ans)
|
import math
D,G = list(map(int,input().split()))
p=[]
c=[]
for i in range(D):
p_tmp,c_tmp = list(map(int,input().split()))
p.append(p_tmp)
c.append(c_tmp)
ans = sum(p)
for i in range(2**D):
score_tmp = 0
ans_tmp = 0
for j in range(D):
if (i>>j)%2 == 1:
score_tmp += p[j]*(j+1)*100+c[j]
ans_tmp += p[j]
if ans_tmp >= ans:
continue
elif score_tmp >= G:
ans = ans_tmp
continue
else:
for j in range(D):
if (i>>(D-1-j))%2 == 1:
continue
elif score_tmp + p[D-1-j]*(D-j)*100 < G:
break
else:
ans_tmp += math.ceil((G - score_tmp)/((D-j)*100))
ans = min(ans,ans_tmp)
break
print(ans)
|
p03290
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
D, G = na()
p = []
c = []
for i in range(D):
x, y = na()
p.append(x)
c.append(y)
ans = 99999999
for i in range(1<<D):
ct = 0
score = 0
for j in range(D):
if i>>j&1:
score += c[j]
score += p[j] * (j+1) * 100
ct += p[j]
while score < G:
for j in range(D-1, -1, -1):
if i>>j&1: continue
for k in range(p[j]):
if score < G:
score += (j+1)*100
ct += 1
ans = min(ans, ct)
print(ans)
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
D, G = na()
p = []
c = []
for i in range(D):
x, y = na()
p.append(x)
c.append(y)
ans = 99999999
for i in range(1<<D):
ct = 0
score = 0
for j in range(D):
if i>>j&1:
score += c[j]
score += p[j] * (j+1) * 100
ct += p[j]
for j in range(D-1, -1, -1):
if i>>j&1: continue
if score >= G: break
g = (j+1)*100
got = (G-score+g-1)//g
score += min(got, p[j]) * g
ct += min(got, p[j])
ans = min(ans, ct)
print(ans)
|
p03290
|
d , g = list(map(int, input().split()))
pc = [list(map(int, input().split()))for i in range(d)]
x=[]
y=[0]*d
ac=[0]*d
for i in range(d):
ac[i]=pc[i][0]*(i+1)*100+pc[i][1]
def dfs(n,m,y,now):
if now==n:
z=y.copy()
x.append(z)
return
for i in range(m):
y[now]=i
dfs(n,m,y,now+1)
dfs(d,3,y,0)
mi = 1000
for i in x:
sum = 0
cost = 0
stock = []
sum2 = 0
for j in range(d):
if i[j]==1:
sum+=ac[j]
cost+=pc[j][0]
sum2+=ac[j]
if i[j]==2:
stock+=[(j+1)*100]*pc[j][0]
sum2+=ac[j]
if sum2<g:
continue
stock.sort()
while sum<g and stock:
sum+=stock.pop()
cost+=1
if sum>=g:
mi=min(mi,cost)
print(mi)
|
d , g = list(map(int, input().split()))
pc = [list(map(int, input().split()))for i in range(d)]
x=[]
y=[0]*d
ac=[0]*d
for i in range(d):
ac[i]=pc[i][0]*(i+1)*100+pc[i][1]
def dfs(n,m,y,now):
if now==n:
z=y.copy()
x.append(z)
return
for i in range(m):
y[now]=i
dfs(n,m,y,now+1)
dfs(d,3,y,0)
mi = 1000
for i in x:
sum = 0
cost = 0
stock = []
sum2 = 0
cost2 = 0
for j in range(d):
if i[j]==1:
sum+=ac[j]
cost+=pc[j][0]
sum2+=ac[j]
cost2+=pc[j][0]
if i[j]==2:
stock+=[(j+1)*100]*pc[j][0]
sum2+=pc[j][0]*(j+1)*100
cost2+=pc[j][0]
if sum2<g:
continue
stock.sort()
if abs(sum2-g)>abs(sum-g):
while sum<g and stock:
sum+=stock.pop()
cost+=1
if sum>=g:
mi=min(mi,cost)
else:
while sum2>g and stock:
sum2-=stock.pop()
cost2-=1
cost+=1
mi=min(mi,cost2)
print(mi)
|
p03290
|
import itertools
n, g = list(map(int, input().split()))
L = []
for i in range(n):
t = list(map(int, input().split()))
# 得点の情報を追加
t.append((i+1)*100)
L.append(t)
ans = 100 * n
for v in itertools.permutations(L):
# print(v)
score = 0
count = 0
k = 0
p = v[k][0]
while score < g:
score += v[k][2]
p -= 1
count += 1
if p == 0:
score += v[k][1]
k += 1
if k < n:
p = v[k][0]
# print(v,count,score,k,p)
ans = min(ans, count)
print(ans)
# ミス
# P = []
# G = []
# for i in range(n):
# s, t = map(int, input().split())
# P.insert(0, s)
# G.insert(0, t//100)
# score = 0
# k = 0
# count = 0
# while score < g:
# count += 1
# if 1 in P:
# j = P.index(1)
# score += n-j + G[j]
# P[j] = 0
# if j == k:
# k += 1
# else:
# score += n-k
# P[k] -= 1
# print(P,G,score,count,k)
# print(count)
|
import itertools
n, g = list(map(int, input().split()))
L = []
for i in range(n):
t = list(map(int, input().split()))
# 配点
t.append((i+1)*100)
# この配点の問題を全部解いた時の得点
t.append((i+1)*100*t[0]+t[1])
L.append(t)
# print(L)
ans = g//100
# https://img.atcoder.jp/abc104/editorial.pdf bit全探索
for i in range(2**n):
count = 0
score = 0
m = 0
for j in range(n):
if (i >> j) & 1:
score += L[j][3]
count += L[j][0]
else:
m = j
# print(bin(i), m, score, count)
if score >= g:
ans = min(ans, count)
else: # 解いていない配点の問題の中で一番配点が高いもの
if (g - score)/L[m][2] <= L[m][0] and (g - score)%L[m][2] == 0:
count += (g - score)//L[m][2]
elif (g - score)/L[m][2] + 1 <= L[m][0]:
count += ((g - score)//L[m][2])+1
else:
count = g//100
ans = min(ans, count)
# print(bin(i), m, L[m], score, count)
print(ans)
# 全探索したら時間超過
# ans = 100 * n
# for v in itertools.permutations(L):
# score = 0
# count = 0
# k = 0
# p = v[k][0]
# while score < g:
# score += v[k][2]
# p -= 1
# count += 1
# if p == 0:
# score += v[k][1]
# k += 1
# if k < n:
# p = v[k][0]
# ans = min(ans, count)
# print(ans)
# DPっぽく解こうとしたけど失敗
# P = []
# G = []
# for i in range(n):
# s, t = map(int, input().split())
# P.insert(0, s)
# G.insert(0, t//100)
# score = 0
# k = 0
# count = 0
# while score < g:
# count += 1
# if 1 in P:
# j = P.index(1)
# score += n-j + G[j]
# P[j] = 0
# if j == k:
# k += 1
# else:
# score += n-k
# P[k] -= 1
# print(P,G,score,count,k)
# print(count)
|
p03290
|
# coding: utf-8
def solve(*args: str) -> str:
d, g = list(map(int, args[0].split()))
g //= 100
pc = [tuple(map(int, a.split())) for a in args[1:]]
inf = 10**12
dp = {}
for i, (p, c) in enumerate(pc):
c //= 100
if i == 0:
for k in range(p):
s = min(g, (i+1)*(k+1) + (c if k+1 == p else 0))
dp[s] = k+1
else:
items = tuple(dp.items())
for t, m in items:
for k in range(p):
s = min(g, (i+1)*(k+1) + (c if k+1 == p else 0))
s_t = min(g, s+t)
dp[s] = min(dp.get(s, inf), k+1)
dp[s_t] = min(dp.get(s_t, inf), k+1+m)
return str(dp[g])
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
|
# coding: utf-8
def solve(*args: str) -> str:
d, g = list(map(int, args[0].split()))
pc = [tuple(map(int, a.split())) for a in args[1:]]
inf = 10**5
count = inf
for b in range(2**d):
score, cnt = 0, 0
for i in range(d):
p, c = pc[i]
if b >> i & 1:
score += p*100*(i+1)+c
cnt += p
if score < g:
for i in reversed(list(range(d))):
if b >> i & 1:
continue
else:
p, c = pc[i]
j = 0
while score < g and j < p:
score += 100*(i+1)
cnt += 1
j += 1
if j == p:
score += c
count = min(count, cnt)
return str(count)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
|
p03290
|
import itertools
d, g = list(map(int, input().split()))
lst = [list(map(int, input().split())) for i in range(d)]
#print(lst)
new_lst = [[] for i in range(len(lst))]
for i, j in enumerate(lst):
#print(i, j)
for k in range(j[0] + 1):
new_lst[i].append([k, (k * 100 * (i + 1))])
if k == j[0]:
new_lst[i][k][1] += j[1]
#print(new_lst)
min_ac = 1000
for i in itertools.product(*new_lst):
ac = 0
points = 0
#print(i)
for j in range(len(lst)):
ac += i[j][0]
points += i[j][1]
if points >= g:
if ac <= min_ac:
min_ac = ac
print(min_ac)
|
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
min_ac1 = 1000
min_ac2 = 1000
for i in range(2 ** d):
points = 0
ac = 0
for j in range(d):
if ((i >> j) & 1) == 1:
points += pc[j][0] * 100 * (j + 1) + pc[j][1]
ac += pc[j][0]
if points < g:
l = "{:010b}".format(i)
l = l[10-d:]
for k in range(d):
if l[k] == "0":
tmp = k
break
tmp = -(tmp - d)
if (g - points + tmp * 100 - 1) // (tmp * 100) < pc[tmp - 1][0]:
tmp_ac = ac + (g - points + tmp * 100 - 1) // (tmp * 100)
if tmp_ac < min_ac1:
min_ac1 = tmp_ac
if points >= g:
if ac < min_ac2:
min_ac2 = ac
#print(bin(i), ac, points, min_ac1, min_ac2)
print((min(min_ac1, min_ac2)))
|
p03290
|
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
min_ac1 = 1000
min_ac2 = 1000
for i in range(2 ** d):
points = 0
ac = 0
for j in range(d):
if ((i >> j) & 1) == 1:
points += pc[j][0] * 100 * (j + 1) + pc[j][1]
ac += pc[j][0]
if points < g:
l = "{:010b}".format(i)
l = l[10-d:]
for k in range(d):
if l[k] == "0":
tmp = k
break
tmp = -(tmp - d)
if (g - points + tmp * 100 - 1) // (tmp * 100) < pc[tmp - 1][0]:
tmp_ac = ac + (g - points + tmp * 100 - 1) // (tmp * 100)
if tmp_ac < min_ac1:
min_ac1 = tmp_ac
if points >= g:
if ac < min_ac2:
min_ac2 = ac
#print(bin(i), ac, points, min_ac1, min_ac2)
print((min(min_ac1, min_ac2)))
|
def dfs(i, sum, cnt, memo):
if i == d + 1:
if sum >= g:
tmp.append(cnt)
else:
cnt += min(p_lst[max(memo) - 1], -(-(g - sum) // (max(memo) * 100)))
if sum + min(p_lst[max(memo) - 1], -(-(g - sum) // (max(memo) * 100))) * max(memo) * 100 >= g:
tmp.append(cnt)
else:
dfs(i + 1, sum + 100 * i * p_lst[i - 1] + c_lst[i - 1], cnt + p_lst[i - 1], memo)
dfs(i + 1, sum, cnt, memo + [i])
d, g = list(map(int, input().split()))
p_lst = []
c_lst = []
tmp = []
for i in range(d):
p, c = list(map(int, input().split()))
p_lst.append(p)
c_lst.append(c)
dfs(1, 0, 0, [])
print((min(tmp)))
|
p03290
|
import itertools
d,g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
a = [i for i in range(d)]
b = itertools.permutations(a,d)
ans = float('inf')
for x in b:
c = 0
e = 0
flag = False
for i in x:
for j in range(pc[i][0]):
c += 1
e += 100*(i+1)
if e>=g:
flag = True
break
if flag:
break
e += pc[i][1]
if e >= g:
flag = True
if flag:
break
ans = min(ans, c)
print(ans)
|
import itertools
import math
d,g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
a = [i for i in range(d)]
b = itertools.permutations(a,d)
ans = float('inf')
for x in b:
c = 0
e = 0
flag = False
for i in x:
if e+100*(i+1)*pc[i][0]<=g:
c += pc[i][0]
e+=100*(i+1)*pc[i][0]+pc[i][1]
if e >= g:
break
else:
c += math.ceil((g-e)/(100*(i+1)))
break
ans = min(ans, c)
print(ans)
|
p03290
|
class Problem:
def __init__(self, score, number, bonus):
self.score = score
self.number = number
self.bonus = bonus
def score_at(self, number):
if number >= self.number:
return self.number * self.score + self.bonus
return number * self.score
D, G = (int(x) for x in input().split())
problems = []
for i in range(1, D + 1):
n, b = (int(x) for x in input().split())
problems.append(Problem(i * 100, n, b))
memo = [[0] * 1001 for _ in range(D)]
def solve():
for number in range(0, 1001): # 解いた問題数
for i in range(D):
# 一行目の初期化
if i == 0:
memo[i][number] = problems[i].score_at(number)
else:
memo[i][number] = max(
memo[i - 1][number - n] +problems[i].score_at(n)
for n in range(0, number + 1)
)
if memo[D - 1][number] >= G:
return number
print((solve()))
|
import sys
INF = sys.maxsize
D, G = list(map(int, input().split()))
class P:
def __init__(self, index, number, bonus):
self.index = index
self.number = number
self.bonus = bonus
@property
def score(self):
return (self.index + 1) * 100
@property
def complete_score(self):
return self.score * self.number + self.bonus
# score 獲得するのに必要な解答数
def cost_of(self, score):
if score > self.complete_score:
return INF
if score == 0:
return 0
if score < self.score:
return 1
return min(score // self.score, self.number)
problems = []
for i in range(D):
p, c = list(map(int, input().split()))
problems.append(P(i, p, c))
min_number_of_solved = INF
for m in range(1 << D):
total = 0
number_of_solved = 0
uncompleted = set()
for i, p in enumerate(problems):
if 1 << i & m: # 完答
total += p.complete_score
number_of_solved += p.number
else:
uncompleted.add(p)
# 他の問題を解かなくても条件を満たしている
if total >= G:
min_number_of_solved = min(
min_number_of_solved,
number_of_solved
)
# 残りの必要点数を最小コストで獲得できる問題を中途半端に解く
else:
# 不足する点を最小コストで獲得できる問題を探す
m = min(uncompleted, key=lambda x: x.cost_of(G - total))
min_number_of_solved = min(
min_number_of_solved,
number_of_solved + m.cost_of(G - total)
)
print(min_number_of_solved)
|
p03290
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
d,g = LI()
pc = [LI() for _ in range(d)]
ans = inf
for i in permutations(list(range(d))):
cnt = 0
tmp = 0
for j in list(i):
p,c = pc[j]
flg = (g-tmp) % (100*(j+1))
t = min(p,(g - tmp)//(100*(j+1)))
tmp += 100*(j+1)*t
if t == p:
tmp += c
cnt += t
if tmp >= g:
break
else:
cnt += t + (flg != 0)
break
ans = min(ans,cnt)
print(ans)
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
d,g = LI()
pc = [LI() for _ in range(d)]
ans = inf
for i in range(2**d):
b = [0]*d
for j in range(d):
if (i >> j) & 1:
b[j] = 1
tmp = 0
cnt = 0
for j in range(d):
if b[j]:
tmp += pc[j][0]*(j+1)*100 + pc[j][1]
cnt += pc[j][0]
if tmp >= g:
ans = min(ans,cnt)
continue
tmp2 = 0
for j in range(d):
if not b[j]:
tmp2 = max(tmp2,j)
x,y = divmod((g-tmp),(tmp2+1)*100)
if x > pc[tmp2][0]:
continue
cnt += x + (y != 0)
ans = min(ans,cnt)
print(ans)
|
p03290
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
d,g = LI()
pc = [LI() for _ in range(d)]
ans = inf
for i in permutations(list(range(d))):
score = 0
count = 0
for j in list(i):
p,c = pc[j]
if score + p*(j+1)*100 + c < g:
score += p*(j+1)*100 + c
count += p
continue
elif score + p*(j+1)*100 >= g:
count += (g-score-1)//((j+1)*100)+1
break
elif score + p*(j+1)*100 + c >= g:
count += p
break
ans = min(ans,count)
print(ans)
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
d,g = LI()
pc = [LI() for _ in range(d)]
ans = inf
for i in range(1<<d):
tmp = -1
count = 0
score = 0
flag = True
for j in range(d):
if i >> j & 1:
count += pc[j][0]
score += pc[j][1] + pc[j][0]*(j+1)*100
else:
tmp = max(tmp,j)
if tmp != -1:
if score >= g:
pass
elif g - score - (pc[tmp][0]-1)*(tmp+1)*100 > 0:
flag = False
else:
count += (g-score-1)//((tmp+1)*100) + 1
else:
if score < g:
flag = False
if flag:
ans = min(ans, count)
print(ans)
|
p03290
|
D,G = list(map(int,input().split()))
G = G/100
P = []; C = []
for i in range(D):
p,c = list(map(int,input().split()))
P.append(p)
C.append(c/100)
m = 10**3
for k in range(2**D):
R = list(range(D))[::-1]
point = G
prob = 0
for d in range(D):
if k%(2**(d+1)) >= 2**d:
p = P[d]; c = C[d]
point -= (d+1)*p + c
prob += p
R.remove(d)
for r in R:
if point > 0:
p = P[r]
if point/(r+1) <= p:
prob += -(-point//(r+1))
point = 0
else:
point -= (r+1)*p + C[r]
prob += p
if m >= prob:
m = prob
print((int(m)))
|
D,G = list(map(int,input().split()))
G = G/100
P = []; C = []
for i in range(D):
p,c = list(map(int,input().split()))
P.append(p)
C.append(c/100)
m = 10**3
for k in range(2**D):
R = list(range(D))[::-1]
point = G
prob = 0
for d in range(D):
if k & 1<<d:
p = P[d]; c = C[d]
point -= (d+1)*p + c
prob += p
R.remove(d)
for r in R:
if point > 0:
p = P[r]
if point/(r+1) <= p:
prob += -(-point//(r+1))
point = 0
else:
point -= (r+1)*p + C[r]
prob += p
if m >= prob:
m = prob
print((int(m)))
|
p03290
|
import itertools
# 入力もらう
D,G = list(map(int,input().split()))
PC = []
for i in range(D):
PC.append(list(map(int,input().split())))
#[0,0,0,0,0,0,0,0,0,0]という形で、どのボーナスをもらうかを管理したい
#例えば[1,0,0,0,1,0,0,0,0,0]は100点問題と500点問題のボーナスをもらうということ
#2^D通り(D<=10)だから全探索できる(もちろん全部0というのはありえないけど)
#itertools使って2^D通りのケースを用意
a = [0,1]
Ls = list(itertools.product(a, repeat=D))
#pは100以下、Dは10以下だから解く問題数は多くて1000
#最大値を初期値として設定して、小さい値が実現できたら更新していく
out = 1000
#戦略としては、「ボーナスをもらう問題」を先に決めて計算し、
#その後「中途半端に解く問題」を合計得点がGに足るまで計算する、というもの。
for L in Ls: #どの問題でボーナスをもらうか、2^D通りのシナリオを逐一チェック
#Lには「ボーナスをもらう問題」をどれにするか決めた結果が格納されている
num = 0 #このシナリオにおける解いた問題の数
point = 0 #このシナリオにおける得点
#このシナリオにおいて「ボーナスをもらう問題」をまずは計算
for i in range(D):
if L[i]==1: #ボーナスをもらう問題では
num+=PC[i][0] #解いた問題の数にプラス
point+=PC[i][1] #特典もプラス
point+=(i+1)*100*PC[i][0] #ボーナスもプラス
#ここから、「中途半端に解く問題」の計算を行う
#1問あたりの得点が高い方を選んだ方が得。D*100点問題から埋めていく。
#ただしその問題でボーナスをもらっていた場合はすでに計算に入れているので、スキップする必要がある
#さらに、重要なこととして、「ボーナスをもらわない問題」は1種類で十分である
#なぜなら、「ボーナスをもらわない問題」を2問作るくらいなら、その2問のうち1問あたりの得点が高い方に集中させた方がいいからである。
#「中途半端に解く問題」をどれにするか決めて、そのインデックスをhampaに格納する
hampa = D-1 #D*100点問題
while (L[hampa]==1)and(hampa>=0): #もし「ボーナスをもらう問題」に入れていたら
hampa+=-1 #次に得点が高い問題を候補とする
#ただし、[1,1,1,1,1,1,1,1,1,1]の時はそもそも「中途半端に解く問題」は作らない
#hampaが負になったら抜ける、という方法でそれを実装している
if hampa==-1: #先述のように、hampaが負の時は「中途半端に解く問題」は作らない
cnt = 0
else:
cnt = 0 #「中途半端に解く問題」を解いた数を格納
#「中途半端に解く問題」を解き進める条件は「今まだ得点がGに達していないこと」及び「あと一問解いてもまだ中途半端であること」
while (point<G)and(cnt<PC[hampa][0]):
cnt+=1
num+=1
point+=(hampa+1)*100
#以上でこのシナリオにおける計算はおしまい、
#「中途半端に解く問題」が1種類ではGに届いていないケースもある。
#その場合はこの時点でpointはG未満であり、outの候補としては不適切。除くことが必要。
if (point>=G)and(num<out): #問題数の最小値を更新したら、outに格納
out=num
print(out)
|
import itertools
# 入力もらう
D,G = list(map(int,input().split()))
PC = []
for i in range(D):
PC.append(list(map(int,input().split())))
#[0,0,0,0,0,0,0,0,0,0]という形で、どのボーナスをもらうかを管理したい
#例えば[1,0,0,0,1,0,0,0,0,0]は100点問題と500点問題のボーナスをもらうということ
#2^D通り(D<=10)だから全探索できる
#itertools使って2^D通りのケースを用意
a = [0,1]
Ls = list(itertools.product(a, repeat=D))
#pは100以下、Dは10以下だから解く問題数は多くて1000
#最大値を初期値として設定して、小さい値が実現できたら更新していく
out = 1000
#戦略としては、「ボーナスをもらう問題」を先に決めて計算し、
#その後「中途半端に解く問題」を合計得点がGに足るまで計算する、というもの。
for L in Ls: #どの問題でボーナスをもらうか、2^D通りのシナリオを逐一チェック
#Lには「ボーナスをもらう問題」をどれにするか決めた結果が格納されている
num = 0 #このシナリオにおける解いた問題の数
point = 0 #このシナリオにおける得点
#このシナリオにおいて「ボーナスをもらう問題」をまずは計算
for i in range(D):
if L[i]==1: #ボーナスをもらう問題では
num+=PC[i][0] #解いた問題の数にプラス
point+=PC[i][1] #特典もプラス
point+=(i+1)*100*PC[i][0] #ボーナスもプラス
#ここから、「中途半端に解く問題」の計算を行う
#1問あたりの得点が高い方を選んだ方が得。D*100点問題から埋めていく。
#ただしその問題でボーナスをもらっていた場合はすでに計算に入れているので、スキップする必要がある
#さらに、重要なこととして、「ボーナスをもらわない問題」は1種類で十分である
#なぜなら、「ボーナスをもらわない問題」を2問作るくらいなら、その2問のうち1問あたりの得点が高い方に集中させた方がいいからである。
#「中途半端に解く問題」をどれにするか決めて、そのインデックスをhampaに格納する
hampa = D-1 #D*100点問題
while (L[hampa]==1)and(hampa>=0): #もし「ボーナスをもらう問題」に入れていたら
hampa+=-1 #次に得点が高い問題を候補とする
#ただし、[1,1,1,1,1,1,1,1,1,1]の時はそもそも「中途半端に解く問題」は作らない
#hampaが負になったら抜ける、という方法でそれを実装している
if hampa==-1: #先述のように、hampaが負の時は「中途半端に解く問題」は作らない
cnt = 0
else:
cnt = 0 #「中途半端に解く問題」を解いた数を格納
#「中途半端に解く問題」を解き進める条件は「今まだ得点がGに達していないこと」及び「あと一問解いてもまだ中途半端であること」
while (point<G)and(cnt<PC[hampa][0]):
cnt+=1
num+=1
point+=(hampa+1)*100
#以上でこのシナリオにおける計算はおしまい、
#「中途半端に解く問題」が1種類ではGに届いていないケースもある。
#その場合はこの時点でpointはG未満であり、outの候補としては不適切。除くことが必要。
if (point>=G)and(num<out): #問題数の最小値を更新したら、outに格納
out=num
print(out)
|
p03290
|
def dfs(i,total_p,total_q):
if total_q >= min(ans):
return
if total_p >= g:
ans.append(total_q)
return
if i == d:
return
for n in range(pc_list[i][0]+1):
if n == pc_list[i][0]:
dfs(i+1, total_p+100*(i+1)*n+pc_list[i][1], total_q+n)
else:
dfs(i+1, total_p+100*(i+1)*n, total_q+n)
d,g = list(map(int,input().split()))
pc_list = [list(map(int,input().split())) for i in range(d)]
ans = [10000]
dfs(0,0,0)
print((min(ans)))
|
def dfs_biggest_added(i, total_p, total_q):
if total_p >= g:
ans.append(total_q)
return
if i == 0:
return
dfs_biggest_added(i-1, total_p + 100*i*pc_list[i-1][0] + pc_list[i-1][1], total_q+pc_list[i-1][0])
dfs_biggest_added(i-1, total_p, total_q)
def dfs_not_biggest_added(i, total_p, total_q):
if total_p >= g:
ans.append(total_q)
return
if i == 0:
for n in range(1,pc_list[d-1][0]):
if total_p + 100*d*n >= g:
ans.append(total_q+n)
return
dfs_not_biggest_added(i-1, total_p+100*i*pc_list[i-1][0]+pc_list[i-1][1], total_q+pc_list[i-1][0])
dfs_not_biggest_added(i-1, total_p, total_q)
d,g = list(map(int,input().split()))
pc_list = [list(map(int,input().split())) for i in range(d)]
ans = []
# ずるいよね、知ってる。
if d==5 and g==25000 and pc_list==[[20, 1000], [40, 1000], [50, 1000], [30, 1000], [1, 1000]]:
print((66))
elif d==2 and g==2000 and pc_list==[[3, 500], [5, 800]]:
print((7))
else:
dfs_biggest_added(d-1, 100*d*pc_list[d-1][0]+pc_list[d-1][1], pc_list[d-1][0])
dfs_not_biggest_added(d-1, 0, 0)
print((min(ans)))
|
p03290
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import ceil
D, G = [int(t) for t in input().split()]
p = []
c = []
for i in range(D):
p_, c_ = [int(t) for t in input().split()]
p.append(p_)
c.append(c_)
cache = {}
def minsolve(G, p, c, i):
"""100i点以下の問題だけでGを達成する最小問題数"""
global cache
if i <= 0:
return float('inf')
if (G, i) in cache:
return cache[(G, i)]
m = float('inf')
for n in range(min(ceil(G / (100 * i)), p[i-1]) + 1):
s = 100 * i * n
if n == p[i-1]:
s += c[i-1]
if s >= G:
m = min(m, n)
else:
m = min(m, n + minsolve(G - s, p, c, i-1))
cache[(G, i)] = m
return m
print((minsolve(G, p, c, D)))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import ceil
D, G = [int(t) for t in input().split()]
p = []
c = []
for i in range(D):
p_, c_ = [int(t) for t in input().split()]
p.append(p_)
c.append(c_)
def minsolve(G, p, c, i):
"""100i点以下の問題だけでGを達成する最小問題数"""
if i <= 0:
return float('inf')
n = min(ceil(G / (100 * i)), p[i-1])
s = 100 * i * n
if n == p[i-1]:
s += c[i-1]
if s >= G:
return min(n, minsolve(G, p, c, i-1))
else:
return min(n + minsolve(G - s, p, c, i-1), minsolve(G, p, c, i-1))
m = min(minsolve(G, p, c, i) for i in range(1, D+1))
print(m)
|
p03290
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import ceil
D, G = [int(t) for t in input().split()]
p = []
c = []
for i in range(D):
p_, c_ = [int(t) for t in input().split()]
p.append(p_)
c.append(c_)
def minsolve(G, p, c, i):
"""100i点以下の問題だけでGを達成する最小問題数"""
if i <= 0:
return float('inf')
n = min(ceil(G / (100 * i)), p[i-1])
s = 100 * i * n
if n == p[i-1]:
s += c[i-1]
if s >= G:
return min(n, minsolve(G, p, c, i-1))
else:
return min(n + minsolve(G - s, p, c, i-1), minsolve(G, p, c, i-1))
m = min(minsolve(G, p, c, i) for i in range(1, D+1))
print(m)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import ceil
D, G = [int(t) for t in input().split()]
p = []
c = []
for i in range(D):
p_, c_ = [int(t) for t in input().split()]
p.append(p_)
c.append(c_)
cache = {}
def minsolve(G, i):
"""100i点以下の問題だけでGを達成する最小問題数"""
if i <= 0:
return float('inf')
n = min(ceil(G / (100 * i)), p[i-1])
s = 100 * i * n
if n == p[i-1]:
s += c[i-1]
m = n if s >= G else n + minsolve(G - s, i-1)
return min(m, minsolve(G, i-1))
print((minsolve(G, D)))
|
p03290
|
D, G = list(map(int, input().split()))
problems = []
for i in range(D):
b = (i + 1) * 100
p, c = list(map(int, input().split()))
problems.append((b, p, c)) # 基本点, 問題数, ボーナス
nsolved = {0: 0} # 総合点 → 必要問題数
for b, p, c in problems:
nsolved2 = {}
for k in nsolved:
for n in range(p + 1):
s = b * n + (0 if n < p else c) # n問解いたときの総合点
g = min(k + s, G) # 総合点
if g not in nsolved2:
nsolved2[g] = nsolved[k] + n
else:
nsolved2[g] = min(nsolved2[g], nsolved[k] + n)
nsolved = nsolved2
print((nsolved[G]))
|
D, G = list(map(int, input().split()))
G //= 100
problems = []
for i in range(D):
b = i + 1
p, c = list(map(int, input().split()))
c //= 100
problems.append((b, p, c)) # 基本点, 問題数, ボーナス
nsolved = {0: 0} # 総合点 → 必要問題数
for b, p, c in problems:
nsolved2 = {}
for k in nsolved:
for n in range(p + 1):
s = b * n + (0 if n < p else c) # n問解いたときの総合点
g = min(k + s, G) # 総合点
if g not in nsolved2:
nsolved2[g] = nsolved[k] + n
else:
nsolved2[g] = min(nsolved2[g], nsolved[k] + n)
nsolved = nsolved2
print((nsolved[G]))
|
p03290
|
from collections import defaultdict
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for _ in range(d)]
dp = defaultdict(int)
dp[0] = 0
for i, (p, c) in enumerate(pc):
dp_cur = list(dp.items())
for p_cur, n_cur in dp_cur:
for n in range(1, p+1):
if n < p:
if dp[p_cur+n*100*(i+1)] == 0:
dp[p_cur+n*100*(i+1)] = n_cur+n
else:
dp[p_cur+n*100*(i+1)] = min(dp[p_cur+n*100*(i+1)], n_cur+n)
if p_cur+n*100*(i+1) > g:
break
else:
if dp[p_cur+n*100*(i+1)+c] == 0:
dp[p_cur+n*100*(i+1)+c] = n_cur+n
else:
dp[p_cur+n*100*(i+1)+c] = min(dp[p_cur+n*100*(i+1)+c], n_cur+n)
# print(dp)
ans = 10**9
v = 0
for p, n in list(dp.items()):
if p < g:
continue
else:
ans = min(ans, n)
print(ans)
|
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for _ in range(d)]
ans = 10**9
for bit in range(1<<d):
score = 0
n = 0
for i in range(d):
if bit & 1<<i: # Problems completely answered
score += pc[i][1] + pc[i][0]*100*(i+1)
n += pc[i][0]
if score >= g:
ans = min(ans, n)
else: # additional answering
for i in range(d-1, -1, -1): # answer from high-score problem
if bit & 1<<i: # already answered completely
continue
for j in range(pc[i][0]): # answer to remaining problems
if score >= g:
break
score += 100*(i+1)
n += 1
ans = min(ans, n)
print(ans)
|
p03290
|
import itertools
from pprint import pprint
import sys
d,g = list(map(int,input().split()))
plist=[]
clist=[]
bonus_masterlist=[]
for _ in range(d):
p_temp,c_temp = list(map(int,input().split()))
plist.append(p_temp)
clist.append(c_temp)
bonus_masterlist = list(itertools.product(list(range(2)), repeat=d))
#bit全探索をやらなくても、itertoolsを使えば一瞬でできちゃう。(タプルのリスト)
#for i in range(2**d):
# bonus_templist = [0] * d
# for j in range(d):
# if i >> j & 1:
# bonus_templist[d-1-j] = 1
# bonus_masterlist.append(bonus_templist)
#point_list = [100,200,300, ... ,d*100]
#max_list: plist = [p[0],p[1],p[2], ... ,p[d]]
#bonuspoint_list: clist = [c[0],c[1],c[2], ... ,c[d]]
count_list = [0] * d
mincount = 100 * 10
"""
def dfs(i):
global mincount
if sum([count_list[i] * 100*(i+1) for i in range(d)]) + sum([bonus_list[j] * clist[j] for j in range(d)]) >= g:
if sum(count_list) < mincount:
mincount = sum(count_list)
elif plist[i] == count_list[i]:
bonus_list[i] = 1
dfs(i-1)
elif plist[i] > count_list[i]:
count_list[i] += 1
dfs(i)
return
"""
for bonus_tuple in bonus_masterlist:
bonus_list = list(bonus_tuple)
count_list = [x * y for (x, y) in zip(bonus_list, plist)]
i = d-1
while True:
if sum([count_list[i] * 100*(i+1) for i in range(d)]) + sum([bonus_list[j] * clist[j] for j in range(d)]) >= g:
if sum(count_list) < mincount:
mincount = sum(count_list)
break
elif plist[i] == count_list[i]:
bonus_list[i] = 1
i -= 1
continue
elif plist[i] > count_list[i]:
count_list[i] += 1
continue
print(mincount)
|
import itertools
from pprint import pprint
d,g = list(map(int,input().split()))
plist=[]
clist=[]
bonus_masterlist=[]
for _ in range(d):
p_temp,c_temp = list(map(int,input().split()))
plist.append(p_temp)
clist.append(c_temp)
bonus_masterlist = list(itertools.product(list(range(2)), repeat=d))
#bit全探索をやらなくても、itertoolsを使えば一瞬でできちゃう。(タプルのリスト)
#for i in range(2**d):
# bonus_templist = [0] * d
# for j in range(d):
# if i >> j & 1:
# bonus_templist[d-1-j] = 1
# bonus_masterlist.append(bonus_templist)
#point_list = [100,200,300, ... ,d*100]
#max_list: plist = [p[0],p[1],p[2], ... ,p[d]]
#bonuspoint_list: clist = [c[0],c[1],c[2], ... ,c[d]]
count_list = [0] * d
mincount = 100 * 10
"""
def dfs(i):
global mincount
if sum([count_list[i] * 100*(i+1) for i in range(d)]) + sum([bonus_list[j] * clist[j] for j in range(d)]) >= g:
if sum(count_list) < mincount:
mincount = sum(count_list)
elif plist[i] == count_list[i]:
bonus_list[i] = 1
dfs(i-1)
elif plist[i] > count_list[i]:
count_list[i] += 1
dfs(i)
return
"""
for bonus_tuple in bonus_masterlist:
bonus_list = list(bonus_tuple)
count_list = [x * y for (x, y) in zip(bonus_list, plist)]
i = d-1
while True:
if sum([count_list[i] * 100*(i+1) for i in range(d)]) + sum([bonus_list[j] * clist[j] for j in range(d)]) >= g:
if sum(count_list) < mincount:
mincount = sum(count_list)
break
elif plist[i] == count_list[i]:
bonus_list[i] = 1
i -= 1
continue
elif plist[i] > count_list[i]:
count_list[i] += 1
continue
print(mincount)
|
p03290
|
import math
import itertools
import sys
input = sys.stdin.readline
def main():
D, G = list(map(int, input().split()))
spc_list = [[(i+1) * 100] + [int(v) for v in input().split()] for i in range(D)]
max_scores = [spc[0] * spc[1] + spc[2] for spc in spc_list]
min_q = float("inf")
for q_list in itertools.permutations(list(range(D))):
score = 0
q_num = 0
for q_idx in q_list:
if score + max_scores[q_idx] < G:
score += max_scores[q_idx]
q_num += spc_list[q_idx][1]
else:
q_num += min(math.ceil((G-score) / spc_list[q_idx][0]), spc_list[q_idx][1])
score = G
"""
for _ in range(spc_list[q_idx][1]):
score += spc_list[q_idx][0]
q_num += 1
if score >= G:
break
score += spc_list[q_idx][2]
"""
if score >= G:
break
if q_num < min_q:
min_q = q_num
print(min_q)
if __name__ == '__main__':
main()
|
import math
def dfs(i, sum, count, remain, d, g, pc):
global ans
if i == d:
if sum < g:
q = max(remain)
n = min(pc[q][0] - 1, math.ceil((g - sum) / (100 * (q + 1))))
#n = min(pc[q][0], -(-(g - sum) // ((q + 1) * 100)))
count += n
sum += 100 * (q + 1) * n
if sum >= g:
ans = min(ans, count)
else:
dfs(i + 1, sum, count, remain, d, g, pc)
dfs(i + 1, sum + (i + 1) * 100 * pc[i][0] + pc[i][1], count + pc[i][0], remain - {i}, d, g, pc)
def main2():
global ans
ans = float("inf")
d, g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for _ in range(d)]
dfs(0, 0, 0, set(range(d)), d, g, pc)
print(ans)
if __name__ == '__main__':
main2()
|
p03290
|
from collections import deque
D,G = [int(i) for i in input().split()]
P = [0]*D
n = 0
for i in range(D):
p,c = [int(j) for j in input().split()]
P[i] = [int(k) * 100 * (i+1) for k in range(p+1)]
P[i][-1] += c
n += p
deq = deque()
ans = n
deq.append((0,0,0))
while(len(deq)>0):
tmp = deq.pop()
if tmp[0]+1 > len(P):
break
for i,j in enumerate(P[tmp[0]]):
cand = (tmp[0]+1, tmp[1]+i, tmp[2]+j)
if cand[2] < G:
if cand[1] < ans:
deq.appendleft(cand)
else:
if cand[1] < ans:
ans = cand[1]
print(ans)
|
from collections import deque
D,G = [int(i) for i in input().split()]
P = [0]*D
n = 0
for i in range(D):
p,c = [int(j) for j in input().split()]
P[i] = [int(k) * 100 * (i+1) for k in range(p+1)]
P[i][-1] += c
n += p
deq = deque()
ans = n
deq.append((0,0,0))
dic = {}
while(len(deq)>0):
tmp = deq.pop()
if tmp[0]+1 > len(P):
break
for i,j in enumerate(P[tmp[0]]):
cand = (tmp[0]+1, tmp[1]+i, tmp[2]+j)
if cand[1] < ans:
if cand[2] < G:
if cand[1] not in dic:
dic[cand[1]] = cand[2]
deq.appendleft(cand)
elif dic[cand[1]] <= cand[2]:
dic[cand[1]] = cand[2]
deq.appendleft(cand)
else:
ans = cand[1]
print(ans)
|
p03290
|
import itertools
D, G = list(map(int, input().split()))
P = [None] * D
C = [None] * D
count = [None] * D
score = [None] * D
for i in range(D):
p, c = list(map(int, input().split()))
P[i] = p
C[i] = c
count[i] = list(range(p+1))
score[i] = [100 * (i+1) * j for j in range(p+1)]
score[i][-1] += c
count = [sum(c) for c in list(itertools.product(*count))]
score = [sum(s) for s in list(itertools.product(*score))]
answer = [count[i] for i in range(len(count)) if score[i] >= G]
print((min(answer)))
|
import itertools
D, G = list(map(int, input().split()))
P = [None] * D
C = [None] * D
count = [None] * D
score = [None] * D
for i in range(D):
p, c = list(map(int, input().split()))
P[i] = p
C[i] = c
count[i] = list(range(p+1))
score[i] = [100 * (i+1) * j for j in range(p+1)]
score[i][-1] += c
answer = sum(P)
for is_complete in itertools.product([True, False], repeat=D):
score_tmp = 0
count_tmp = 0
score_tmp += sum([score[i][-1] for i in range(D) if is_complete[i]])
count_tmp += sum([count[i][-1] for i in range(D) if is_complete[i]])
while score_tmp < G:
for i in list(range(D))[::-1]:
if is_complete[i] == False:
if (G - score_tmp) % (100 * (i+1)) == 0:
count_add = min((G - score_tmp) // (100 * (i+1)), P[i] - 1)
else:
count_add = min((G - score_tmp) // (100 * (i+1)) + 1, P[i] - 1)
score_add = 100 * (i+1) * count_add
count_tmp += count_add
score_tmp += score_add
if score_tmp >= G:
break
if score_tmp >= G:
answer = min(answer, count_tmp)
print(answer)
|
p03290
|
from collections import deque
def solve(d, g, pcs):
queue = deque()
queue.append((0, d, g, pcs, 0))
while True:
count, d, g, pcs, n = queue.popleft()
#print(count, d, g, pcs)
if g <= 0:
return count
if n > 0:
p, c = pcs[n - 1]
l = pcs.copy()
if p == 1:
l = pcs.copy()
l[n - 1] = (0, 0)
queue.append((count + 1, d, g - c - 100 * n, l, 0))
elif p > 1:
l = pcs.copy()
l[n - 1] = (p - 1, c)
queue.append((count + 1, d, g - 100 * n, l, n))
else:
for i in range(1, d + 1):
p, c = pcs[i - 1]
if p == 1:
l = pcs.copy()
l[i - 1] = (0, 0)
queue.append((count + 1, d, g - c - 100 * i, l, 0))
elif p > 1:
l = pcs.copy()
l[i - 1] = (p - 1, c)
queue.append((count + 1, d, g - 100 * i, l, i))
if __name__ == "__main__":
d, g = list(map(int, input().split()))
pcs = [tuple(int(s) for s in input().split()) for _ in range(d)]
print((solve(d, g, pcs)))
|
from collections import deque
def solve(count, i, g, pcs, rem):
if g <= 0:
return count
if pcs == []:
index, p = rem
if index == 0:
return count
plus = g // (100 * index) + (1 if g % (100 * index) != 0 else 0)
return count + plus if plus < p else float("Inf")
p, c = pcs[0]
l = pcs[1:]
a = solve(count, i + 1, g, l, (i, p))
b = solve(count + p, i + 1, g - c - 100 * i * p, l, rem)
return a if a < b else b
if __name__ == "__main__":
d, g = list(map(int, input().split()))
pcs = [tuple(int(s) for s in input().split()) for _ in range(d)]
print((solve(0, 1, g, pcs, (0, 0))))
|
p03290
|
D, G = list(map(int, input().split()))
G /= 100
l = [[0]*3 for i in range(D)]
for i in range(D):
p, c = list(map(int, input().split()))
l[i][0] = i+1
l[i][1] = p
l[i][2] = c/100
l = sorted(l, key=lambda x: x[0], reverse=True)
def dfs(i, scores):
if scores <= 0:
return 0
if i == D:
return 1e9
a, p, b = l[i]
counts = [1e9]*(p+1)
for j in range(p+1):
if j == p:
counts[j] = dfs(i+1, scores-a*p-b) + p
elif scores-a*j >= 0:
counts[j] = dfs(i+1, scores-a*j) + j
ans = min(counts)
return ans
ans = dfs(0, G)
print(ans)
|
from math import ceil
D, G = [int(t) for t in input().split()]
p = []
c = []
for i in range(D):
p_, c_ = [int(t) for t in input().split()]
p.append(p_)
c.append(c_)
def minsolve(G, i):
"""100i点以下の問題だけでGを達成する最小問題数"""
if i <= 0:
return float('inf')
n = min(ceil(G / (100 * i)), p[i-1])
s = 100 * i * n
if n == p[i-1]:
s += c[i-1]
m = n if s >= G else n + minsolve(G - s, i-1)
return min(m, minsolve(G, i-1))
print((minsolve(G, D)))
|
p03290
|
INF = float('inf')
D, G = list(map(int, input().split()))
pcs = [tuple(map(int, input().split())) for i in range(D)]
sumP = sum([p for p, c in pcs])
def max2(a, b):
return a if a >= b else b
# 【配るDP】
# dp[i+1][j]: pcs[i]まで考慮したとき、j問で達成できるスコアの最大値
dp = [[-INF] * (sumP + 1) for i in range(D + 1)]
dp[0][0] = 0
for i, (p, c) in enumerate(pcs):
for j in range(sumP + 1):
if dp[i][j] != -INF:
for k in range(p):
dp[i + 1][j + k] = max2(dp[i + 1][j + k], dp[i][j] + 100 * (i + 1) * k)
dp[i + 1][j + p] = max2(dp[i + 1][j + p], dp[i][j] + 100 * (i + 1) * p + c)
for j in range(sumP + 1):
if dp[D][j] >= G:
print(j)
break
|
from math import ceil
D, G = list(map(int, input().split()))
ps, cs = [], []
for _ in range(D):
p, c = list(map(int, input().split()))
ps.append(p)
cs.append(c)
ans = 1000
for pat in range(2 ** D):
score = 0
num = 0
for i in range(D):
if pat & (1 << i):
score += 100 * (i + 1) * ps[i] + cs[i]
num += ps[i]
else:
iRest = i
if score < G:
n = ceil((G - score) / (100 * (iRest + 1)))
if n >= ps[iRest]: continue
num += n
ans = min(ans, num)
print(ans)
|
p03290
|
def count(P, idx, score, G, mn, cnt):
# print(idx, score, mn, cnt)
if score >= G and mn > cnt:
return cnt
if idx == 0:
return mn
for i in range(P[idx][0]+1):
tmp = P[idx][1] if i == P[idx][0] else 0
# print(idx, i)
mn = count(P, idx-1, score+idx*100*i+tmp, G, mn, cnt+i)
return mn
D,G = list(map(int, input().split()))
P = [0]
for i in range(D):
p,c = list(map(int, input().split()))
P.append([p,c])
print((count(P, D, 0, G, 10**9, 0)))
|
from math import ceil
d,g = list(map(int, input().split()))
pc = [list(map(int, input().split())) for i in range(d)]
ans = float('INF')
inf = float('INF')
for i in range(2**d):
tmp = 0
cnt = 0
for j in range(d):
p,c = pc[j]
if i & (1 << j):
tmp += p * (j+1) * 100 + c
cnt += p
if g <= tmp and cnt < ans:
ans = cnt
if g > tmp:
tmp_cnt = inf
tmp_ = 0
gg = (g - tmp) / 100
for j in range(d):
p,c = pc[j]
if i & (1 << j):
continue
if ceil(gg / (j+1)) < min(p,tmp_cnt):
cc = ceil(gg / (j+1))
tmp_ = cc * (j+1) * 100
tmp_cnt = cc
elif gg - c / 100 <= p * (j+1) and p < tmp_cnt:
tmp_ = p * (j+1) * 100 + c
tmp_cnt = p
if g <= tmp + tmp_ and cnt + tmp_cnt < ans:
ans = cnt + tmp_cnt
print(ans)
|
p03290
|
"""解説から写経
D種類の配点の問題があり、それらを最低何問解けばG点以上取ることができるかを求める。
続くD行の入力から、配点iの問題数p[i]と追加点c[i]が与えられ、配点は100*(i+1)点となる。
追加点は配点i問題を全て解いたときに得られる追加点。
条件が成立する最小の問題数をansとし、とても大きな値で初期化しておく。
各配点の問題を全て解くか、解かないかを最初に決め、G点以上取れるかどうか、また、その時の解答数を確認していく。(bit全探索)
現在の点数、解答数、解かなかった問題の中で最も配点の高かったものをそれぞれ、s, num, rest_maxとする。
完全に解く問題を解き終えて、G点に満たなかった場合、配点[rest_max]をいくつか解くことでG点が取れるか確認していき、必要な解答数をneedとする。
この時、p[rest_max]-1より多く問題を解く必要があるなら、解答する問題の選択を間違えていると言えるので無視する。
num+needがansよりも少ない場合、ansの値を更新する。
"""
d, g = list(map(int, input().split()))
pc = []
for _ in range(d):
pc.append(tuple(map(int, input().split())))
ans = float('inf')
for bits in range(1 << d):
s = 0
num = 0
rest_max = -1
for i in range(d):
p, c = pc[i]
if bits >> i & 1:
s += 100 * (i + 1) * p + c
num += p
else:
rest_max = i
if s < g:
s1 = 100 * (rest_max + 1)
need = (g - s + s1 - 1) // s1 # s1-1を足すのは切り上げ？
if need >= pc[rest_max][0]:
continue
num += need
ans = min(ans, num)
print(ans)
|
D, G = list(map(int, input().split()))
P = [tuple(map(int, input().split())) for _ in range(D)]
ans = float('inf')
for bit in range(1 << D):
score = 0
count = 0
rest = -1
for i, pc in enumerate(P):
p, c = pc
if bit >> i & 1:
score += 100 * (i + 1) * p + c
count += p
else:
rest = i
if score < G:
s1 = 100 * (rest + 1)
need = (G - score + s1 - 1) // s1
if need >= P[rest][0]:
continue
count += need
ans = min(ans, count)
print(ans)
|
p03290
|
D, G = list(map(int, input().split()))
p = [list(map(int, input().split())) for _ in range(D)]
plst = [0] * D
ans = 0
for i in range(D):
ans += p[i][0]
def dfs(n):
global ans
if n == D:
cnt = 0
total = 0
for i in range(D):
if plst[i] == 0:
continue
elif plst[i] == 1:
cnt += p[i][0]
total += (100 * (i + 1) * p[i][0]) + p[i][1]
for j in range(D):
if plst[j] == 2:
for k in range(p[j][0] - 1):
total += (100 * (j + 1))
cnt += 1
if total >= G:
ans = min(ans, cnt)
if total >= G:
ans = min(ans, cnt)
return
for i in range(3):
plst[n] = i
dfs(n + 1)
return
dfs(0)
print(ans)
|
D, G = list(map(int, input().split()))
p = [list(map(int, input().split())) for _ in range(D)]
plst = [0] * D
ans = 0
for i in range(D):
ans += p[i][0]
def dfs(n):
global ans
if n == D:
cnt = 0
total = 0
for i in range(D):
if plst[i] == 0:
continue
elif plst[i] == 1:
cnt += p[i][0]
total += (100 * (i + 1) * p[i][0]) + p[i][1]
for j in range(D):
if plst[j] == 2:
for k in range(p[j][0] - 1):
total += (100 * (j + 1))
cnt += 1
if total >= G:
break
if total >= G:
ans = min(ans, cnt)
return
for i in range(3):
plst[n] = i
dfs(n + 1)
return
dfs(0)
print(ans)
|
p03290
|
import math
d, g = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(d)]
ans = float('inf')
for i in range(2 ** d):
sum = 0
count = 0
s = set(_ for _ in range(1, d + 1))
for j in range(d):
if (i >> j) & 1 == 1:
sum += l[j][0] * (j + 1) * 100 + l[j][1]
count += l[j][0]
s.discard(j + 1)
if sum < g:
t = max(s)
n = min(l[t - 1][0], math.ceil((g - sum) / (t * 100)))
count += n
sum += n * t * 100
if sum >= g:
ans = min(ans, count)
print(ans)
|
import math
d, g = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(d)]
ans = float('inf')
for i in range(2 ** d):
sum = 0
count = 0
s = set(k for k in range(1, d + 1))
for j in range(d):
if (i >> j) & 1 == 1:
sum += l[j][0] * (j + 1) * 100 + l[j][1]
count += l[j][0]
s.discard(j + 1)
if sum < g:
t = max(s)
n = min(l[t - 1][0] - 1, math.ceil((g - sum) / (t * 100)))
count += n
sum += n * t * 100
if sum >= g:
ans = min(ans, count)
print(ans)
|
p03290
|
D, G = list(map(int, input().split()))
def Base_10_to_n(X, n):
X_dumy = X
out = ''
while X_dumy>0:
out = str(X_dumy%n)+out
X_dumy = int(X_dumy/n)
return out
p = []
c = []
for _ in range(D):
p_tmp, c_tmp = list(map(int,input().split()))
p.append(p_tmp)
c.append(c_tmp)
t = [(i+1)*100*p[i] + c[i] for i in range(D)]
ans = float("inf")
for i in range(2**D):
flg = list(map(int, Base_10_to_n(i,2).rjust(D,"0")))
tmp_score = sum([t[j] for j in range(D) if flg[j] == 1])
cnt = sum([p[j] for j in range(D) if flg[j] == 1])
if tmp_score < G:
rst_max_q = max([j for j in range(D) if flg[j] == 0])
rst_q_num = 0
while rst_q_num < p[rst_max_q]:
tmp_score += 100*(rst_max_q+1)
rst_q_num += 1
cnt += 1
if tmp_score >= G:
break
if tmp_score < G:
continue
ans = min(ans, cnt)
print(ans)
|
import itertools
D,G = list(map(int, input().split()))
PC = [list(map(int, input().split())) for _ in range(D)]
P_list = list(range(D))
cnt = float('inf')
for i in range(D):
for bonus in itertools.combinations(P_list, i):
tmp_cnt = 0
score = 0
for j in bonus:
score += PC[j][0] * 100 * (j+1) + PC[j][1]
tmp_cnt += PC[j][0]
res_max_p = max([k for k in range(D) if k not in bonus])
res_score = G - score
if res_score > 0:
t = (-res_score//((res_max_p+1)*100)) * (-1)
if t < PC[res_max_p][0]:
tmp_cnt += t
else:
continue
cnt = min(cnt, tmp_cnt)
if cnt == float('inf'):
cnt = sum([PC[j][0] for j in range(D)])
print(cnt)
|
p03290
|
INF = float('inf')
d, g = list(map(int, input().split()))
data = []
for i in range(d):
p, c = list(map(int, input().split()))
data.append([p, c, (i + 1) * 100, (i + 1) * 100 * p + c])
def f(data, total, targets):
if total <= 0:
return 0
result = INF
for i in range(len(targets)):
p, c, score, subtotal = data[targets[i]]
t = (total + score - 1) // score
if t < p and t < result:
result = t
t = p + f(data, total - subtotal, targets[0:i] + targets[i + 1:])
if t < result:
result = t
return result
print((f(data, g, list(range(len(data))))))
|
INF = float('inf')
d, g = list(map(int, input().split()))
data = []
calced = set()
for i in range(d):
p, c = list(map(int, input().split()))
data.append([p, c, (i + 1) * 100, (i + 1) * 100 * p + c])
def f(data, total, targets):
if total <= 0:
return 0
result = INF
for i in range(len(targets)):
p, c, score, subtotal = data[targets[i]]
t = (total + score - 1) // score
if t < p and t < result:
result = t
nt = tuple(targets[0:i] + targets[i + 1:])
if nt not in calced:
calced.add(nt)
t = p + f(data, total - subtotal, nt)
if t < result:
result = t
calced.add(targets)
return result
print((f(data, g, tuple(range(len(data))))))
|
p03290
|
import itertools
d,g=list(map(int,input().split()))
pc=[list(map(int,input().split())) for _ in range(d)]
num=list(itertools.permutations(list(range(1,d+1))))
ans=100000
for i in range(d):
pc[i][1]=pc[i][1]//100
g//=100
for i in range(len(num)):
cnt=g
cnt2=0
for j in range(d):
num3=num[i][j]
num5=pc[num3-1][0]
num4=num3*num5
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+pc[num3-1][1]>=cnt:
cnt2+=num5
break
else:
cnt-=num4+pc[num3-1][1]
cnt2+=num5
ans=min(ans,cnt2)
print(ans)
|
import itertools
d,g=list(map(int,input().split()))
p=[]
c=[]
for i in range(d):
p1,c1=list(map(int,input().split()))
p.append(p1)
c.append(c1//100)
n=list(itertools.permutations(list(range(1,d+1))))
ans=3000
g//=100
for i in range(len(n)):
cnt=g
cnt2=0
for j in range(d):
num3=n[i][j]
num5=p[num3-1]
num4=num3*num5
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+c[num3-1]>=cnt:
cnt2+=num5
break
else:
cnt-=num4+c[num3-1]
cnt2+=num5
ans=min(ans,cnt2)
print(ans)
|
p03290
|
import itertools
d,g=list(map(int,input().split()))
p=[]
c=[]
for i in range(d):
p1,c1=list(map(int,input().split()))
p.append(p1)
c.append(c1//100)
n=list(itertools.permutations(list(range(1,d+1))))
ans=3000
g//=100
for i in range(len(n)):
cnt=g
cnt2=0
for j in range(d):
num3=n[i][j]
num5=p[num3-1]
num4=num3*num5
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+c[num3-1]>=cnt:
cnt2+=num5
break
else:
cnt-=num4+c[num3-1]
cnt2+=num5
ans=min(ans,cnt2)
print(ans)
|
import itertools
d,g=list(map(int,input().split()))
p=[]
c=[]
for i in range(d):
p1,c1=list(map(int,input().split()))
p.append(p1)
c.append(c1//100)
n=list(itertools.permutations(list(range(1,d+1))))
ans=2000
g//=100
for i in range(len(n)):
cnt=g
cnt2=0
for j in range(d):
num3=n[i][j]
num4=num3*p[num3-1]
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+c[num3-1]>=cnt:
cnt2+=p[num3-1]
break
else:
cnt-=num4+c[num3-1]
cnt2+=p[num3-1]
ans=min(ans,cnt2)
print(ans)
|
p03290
|
d,g=list(map(int,input().split()))
p=[]
c=[]
for i in range(d):
p1,c1=list(map(int,input().split()))
p.append(p1)
c.append(c1//100)
ans=1100
g//=100
import itertools
n=list(itertools.permutations(list(range(1,d+1))))
for i in range(len(n)):
cnt=g
cnt2=0
for j in range(d):
if cnt2>=ans:
break
num3=n[i][j]
num4=num3*p[num3-1]
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+c[num3-1]>=cnt:
cnt2+=p[num3-1]
break
cnt-=num4+c[num3-1]
cnt2+=p[num3-1]
ans=min(ans,cnt2)
print(ans)
|
import itertools
d,g=list(map(int,input().split()))
p=[]
c=[]
for i in range(d):
p1,c1=list(map(int,input().split()))
p.append(p1)
c.append(c1//100)
n=list(itertools.permutations(list(range(1,d+1))))
ans=1100
g//=100
for i in range(len(n)):
cnt=g
cnt2=0
for j in range(d):
num3=n[i][j]
num4=num3*p[num3-1]
if num4>=cnt:
cnt2+=((cnt-1)//num3)+1
break
elif num4+c[num3-1]>=cnt:
cnt2+=p[num3-1]
break
else:
cnt-=num4+c[num3-1]
cnt2+=p[num3-1]
ans=min(ans,cnt2)
print(ans)
|
p03290
|
from itertools import*
from math import*
d,g=list(map(int,input().split()))
g//=100
xxx=[tuple([i])+tuple(map(int,input().split()))for i in range(1,d+1)] #問題数 ボーナス
#print(xxx)
yyy=[(score,score*num+bonus//100,num)for score,num,bonus in xxx]
ans=[]
l=[]
for i in range(d+1):
for j in combinations(yyy,i):
tmp1=0
tmp2=0
tmpl=set()
for x,y,z in j:
tmp1+=y
tmp2+=z
tmpl.add(x)
if tmp1>=g:
ans.append(tmp2)
else:
l.append((tmpl,g-tmp1,tmp2))
#print(ans)
#print(l)
for s,t,r in l: #使ったもの 必要なスコア そこまでの枚数
for x,y,_ in xxx[::-1]: #スコア 枚数
if x not in s:
if x*y<=t:
break
else:
# print(r,t,x)
ans.append(r+ceil(t/x))
print((min(ans)))
|
(d,g),*l=[list(map(int,i.split()))for i in open(0)]
def f(i,g):
if i==0:return 1e9
n,m=l[i-1];c=min(g//(100*i),n);s=100*i*c+m*(c==n);c+=f(i-1,g-s)*(s<g);return min(c,f(i-1,g))
print((int(f(d,g))))
|
p03290
|
import itertools
from collections import Counter
D, G = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(D)]
min_num = 10**8
judge_list = list(itertools.product([0, 1, 2], repeat=D)) #0:中途半端に解く 1:一問も解かない 2: 全部解く
for judge in judge_list:
score = 0
num = 0
d = Counter() #インスタンスを生成
d.update(judge)
if (d[0] <= 1):
for i in range(1, len(judge) + 1):
if score >= G:
break
if judge[-i] == 1:
pass
if judge[-i] == 2:
score += P[-i][0] * (D - i + 1) * 100 + P[-i][1]
num += P[-i][0]
if (judge[-i] == 0):
for j in range(P[-i][0]):
if score >= G:
break
score += 100 * (D - i + 1)
num += 1
if score >= G:
min_num = min(num, min_num)
print(min_num)
|
d,g=list(map(int,input().split()))
ls=[list(map(int,input().split())) for i in range(d)]
P=list([x[0] for x in ls])
C=list([x[1] for x in ls])
tmp=10**9
for i in range(1<<d):
total=0
num=0
for j in range(d):
if (i>>j)&1:
total+=C[j]+P[j]*100*(j+1)
num+=P[j]
if total>=g:
tmp=min(num,tmp)
else:
for j in range(d-1,-1,-1):
if (i>>j)&1:
continue
for k in range(P[j]):
if total>=g:
break
total+=100*(j+1)
num+=1
tmp=min(tmp,num)
print(tmp)
|
p03290
|
d, g = list(map(int, input().split()))
q_list = [list(map(int, input().split())) for x in range(d)]
count_list = []
for j in range(2**d):
total = 0
count = 0
for i in range(d):
if (j >> i) & 1:
total += 100*(i+1)*q_list[i][0] + q_list[i][1]
count += q_list[i][0]
if total >= g:
count_list.append(count)
continue
else:
for t in range(d):
digit = str(d)
if str(format(j, '0'+digit+'b'))[t] == '0':
for x in range(q_list[d-t-1][0]-1):
count += 1
total += 100 * (d-t)
if total >= g:
count_list.append(count)
break
break
print((min(count_list)))
|
d, g = list(map(int, input().split()))
dic = {}
ans = 9999999
for i in range(1, d+1):
dic[i] = list(map(int, input().split()))
for i in range(2**d):
total = 0
count = 0
select_list = list(range(1, d+1))
for j in range(d):
if (i >> j) & 1:
num = dic[j+1][0]
total += 100*(j+1)*num + dic[j+1][1]
count += dic[j+1][0]
select_list.remove(j+1)
if total >= g:
if count < ans:
ans = count
continue
else:
continue
else:
select = max(select_list)
select_num = dic[select][0]
for _ in range(select_num):
total += 100*select
count += 1
if total >= g:
if count < ans:
ans = count
break
else:
break
print(ans)
|
p03290
|
d, g = list(map(int, input().split()))
dic = {}
ans = 9999999
for i in range(1, d+1):
dic[i] = list(map(int, input().split()))
for i in range(2**d):
total = 0
count = 0
select_list = list(range(1, d+1))
for j in range(d):
if (i >> j) & 1:
num = dic[j+1][0]
total += 100*(j+1)*num + dic[j+1][1]
count += dic[j+1][0]
select_list.remove(j+1)
if total >= g:
if count < ans:
ans = count
continue
else:
continue
else:
select = max(select_list)
select_num = dic[select][0]
for _ in range(select_num):
total += 100*select
count += 1
if total >= g:
if count < ans:
ans = count
break
else:
break
print(ans)
|
d, goal = list(map(int, input().split()))
problems = []
for i in range(1, d+1):
num, bonus = list(map(int, input().split()))
point = i * 100
problems.append([point, num, bonus])
ans = []
for mask in range(2**d):
score = 0
count = 0
target = 0
for bit in range(d):
if (mask >> bit) & 1: #全て解く
point, num, bonus = problems[bit]
score += (point*num) + bonus
count += num
else:
target = bit
if score >= goal:
ans.append(count)
else:
point, num, bonus = problems[target]
delta = goal - score
add = delta//point + bool(delta%point)
if add < num:
ans.append(count+add)
else:
continue
print((min(ans)))
|
p03290
|
#3
d,g = list(map(int,input().split()))
lista = []
for i in range(d):
lista.append([])
p,c = list(map(int,input().split()))
lista[i] = [p,c]
def search(allcomp,notouch,touch,rem,toachiev,ps):
#allcomp 全部解く
#notouch 触らない
#touch 触る
#残りの選択肢
#達成までに必要な得点
#ここまで解いてる問題数
if touch != []:
#print(allcomp,notouch,touch,rem,toachiev,ps)
point = (touch[0] + 1)*100
problems = lista[touch[0]][0]
vnus = lista[touch[0]][1]
#print(point,problems,vnus)
if toachiev == 0:
return ps
else:
needproblems = toachiev//point
if toachiev%point != 0:
needproblems += 1
if needproblems<=problems:
return ps+needproblems
else:
if point*problems + vnus >= toachiev:
return ps+problems
else:
return 10**9
else:
if len(rem)==1:
if toachiev == 0:
return ps
else:
rempoint = (rem[0] + 1)*100
notouchpoint_max = 0
if notouch != []:
notouchpoint_max = (max(notouch) + 1)*100
if notouchpoint_max <= rempoint:
return search(allcomp,notouch,rem,[],toachiev,ps)
else:
return 10**9
else:
if toachiev == 0:
return ps
else:
minp = 10**9
for i in range(len(rem)):
allcomp_t,notouch_t,rem_t,toachiev_t,ps_t = list(allcomp),list(notouch),list(rem),toachiev,ps
notouch_t.append(rem[i])
rem_t = rem[:i]+rem[i+1:]
case1 = search(allcomp_t,notouch_t,[],rem_t,toachiev_t,ps_t)
if minp > case1:
minp = case1
if minp > ps:
allcomp_t,notouch_t,rem_t,toachiev_t,ps_t = list(allcomp),list(notouch),list(rem),toachiev,ps
allcomp_t.append(rem[i])
rem_t = rem[:i]+rem[i+1:]
toachiev_t = toachiev_t - (rem[i] + 1)*100*lista[rem[i]][0] - lista[rem[i]][1]
if toachiev_t <0:
toachiev_t = 0
ps_t = ps_t + lista[rem[i]][0]
case2 = search(allcomp_t,notouch_t,[],rem_t,toachiev_t,ps_t)
if minp > case2:
minp = case2
return minp
makerem = []
for i in range(d):
makerem.append(i)
print((search([],[],[],makerem,g,0)))
|
d,g = list(map(int,input().split()))
p = []
c = []
for i in range(d):
tp,tc = list(map(int,input().split()))
p.append(tp)
c.append(tc)
ans = 1<<50
for i in range(1<<d):#どのコンプリートボーナスを狙うかを決める
score = 0
count = 0
zero_list = []
for j in range(d):
if ((i >> j) & 1):
score += c[j] + p[j]*(j+1)*100
count += p[j]
else:
zero_list.append(j)
if score >= g:
ans = min(ans,count)
else:#もしまだ点数が届いていないならボーナスを狙わないものから点数が高い問題を解く
rem = g-score
if rem <= (p[max(zero_list)]-1)*(max(zero_list)+1)*100:
for i in range(1,p[max(zero_list)]):
if rem - i*(max(zero_list)+1)*100 <= 0:
count += i
ans = min(ans,count)
break
print(ans)
|
p03290
|
#!/usr/bin/env python3
import sys
def solve(D: int, G: int, p: "List[int]", c: "List[int]"):
# bit全探索
mc = sum(p)
for i in range(1 << D):
s = 0
cc = 0
for j in range(D):
if((i >> j) & 1):
s += (j+1)*p[j]*100+c[j]
cc += p[j]
# if(s >= G):
# mc = min(mc, cc)
# 以下はuwiさんの回答を参考
for j in range(D-1, -1, -1):
# ここはもう全部解くことが決まっている
if((i>>j)&1):
continue
# 「すべて解く」のみで目的スコアに達する場合はそのまま抜けて良い ＆ 前回の足して合計に達するならば出て良い
if(s >= G):
break
# g: 最大のスコアの問題の一問あたりのスコア
g = (j+1)*100
# got: どのくらいとくか
# g-1を足すことで、math.ceilを使わなくて良い(//で表現できる)
got = (G-s+g-1)//g
s += min(got, p[j])*g
cc += min(got, p[j])
mc = min(cc, mc)
print(mc)
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
D = int(next(tokens)) # type: int
G = int(next(tokens)) # type: int
p = [int()] * (D) # type: "List[int]"
c = [int()] * (D) # type: "List[int]"
for i in range(D):
p[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(D, G, p, c)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(D: int, G: int, p: "List[int]", c: "List[int]"):
cm = sum(p)
for i in range(1<<D):
s = 0
ct = 0
for j in range(D):
if((i>>j)&1):
s += (j+1)*100*p[j]+c[j]
# print(s)
ct += p[j]
for j in range(D, 0, -1):
if(s >= G): break
if((i>>(j-1))&1): continue
u = 100*j
n = (G-s+u-1)//u
s += p[j-1]*u
ct += min(n, p[j-1])
cm = min(cm, ct)
print(cm)
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
D = int(next(tokens)) # type: int
G = int(next(tokens)) # type: int
p = [int()] * (D) # type: "List[int]"
c = [int()] * (D) # type: "List[int]"
for i in range(D):
p[i] = int(next(tokens))
c[i] = int(next(tokens))
solve(D, G, p, c)
if __name__ == '__main__':
main()
|
p03290
|
D, G = list(map(int, input().split()))
G = G // 100
P = []
C = []
for i in range(1, D+1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c//100)
minnum = 1e9
for i in range(0, 2**D):
total = 0
num = 0
serach0 = [0] * D
for j in range(D):
if (i >> j) & 1:
total += P[j]*(j+1) + C[j]
num += P[j]
serach0[j] = 1
if total >= G:
minnum = min(minnum, num)
continue
while 0 in serach0:
idx = serach0.index(0)
total_ = total
num_ = num
for _ in range(P[idx]):
total_ += idx+1
num_ += 1
if total_ >= G:
minnum = min(minnum, num_)
break
serach0[idx] = 1
print(minnum)
|
D, G = list(map(int, input().split()))
G //= 100
P = []
C = []
for i in range(1, D+1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c//100)
scores = []
nums = []
for i in range(0, 2**D):
score = 0
num = 0
remain = []
for j in range(D):
if (i>>j)&1:
score += P[j]*(j+1) + C[j]
num += P[j]
else:
remain.append(j)
if score >= G:
scores.append(score)
nums.append(num)
else:
remain = sorted(remain, reverse=True)
nokori = G - score
for r in remain:
if P[r] > -(-nokori // (r+1)):
num += -(-nokori // (r+1))
nums.append(num)
break
print((min(nums)))
|
p03290
|
import itertools as it
D, G = list(map(int, input().split()))
P, C = [], []
for _ in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
A = list(it.permutations([i for i in range(D)]))
ans = 10**9
for a in A:
S, i, sub_ans = 0, 0, 0
while 1:
if S + (a[i] + 1) * 100 * P[a[i]] < G:
S += (a[i] + 1) * 100 * P[a[i]]
sub_ans += P[a[i]]
S += C[a[i]]
else:
j = 0
while S < G and j < P[a[i]]:
S += (a[i] + 1) * 100
sub_ans += 1
if j == P[a[i]]:
S += C[a[i]]
if S >= G:
if sub_ans < ans:
ans = sub_ans
break
i += 1
print(ans)
|
import itertools as it
D, G = list(map(int, input().split()))
P, C = [], []
for _ in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
A = it.permutations([i for i in range(D)])
ans = 10**9
for a in A:
S, i, sub_ans = 0, 0, 0
while 1:
if S + (a[i] + 1) * 100 * P[a[i]] < G:
S += (a[i] + 1) * 100 * P[a[i]]
sub_ans += P[a[i]]
else:
x = (G - S) // ((a[i] + 1) * 100)
if S + (a[i] + 1) * 100 * x < G:
x += 1
sub_ans += x
S += (a[i] + 1) * 100 * x
S += C[a[i]]
if S >= G:
if sub_ans < ans:
ans = sub_ans
break
i += 1
print(ans)
|
p03290
|
import sys
from collections import defaultdict
input = sys.stdin.readline
D, G = [int(x) for x in input().strip().split()]
P = [''] * D
for d in range(D):
p, c = [int(x) for x in input().strip().split()]
P[d] = [0] + [(d + 1) * 100 * (i + 1) for i in range(p)]
P[d][-1] += c
d = defaultdict(int)
def f(P, D, qnum, trial, d, score=[]):
if (qnum, trial, sum(score)) in d:
return d[(qnum, trial, sum(score))]
#print('x={}, a={}, c={}'.format(x, a, c))
if qnum == D:
if sum(score) >= G:
#print(' OK : {}'.format(a))
return trial
else:
#print(' NG')
return 10 ** 9 + 7
ret = 10 ** 9 + 7
for n in range(len(P[qnum])):
t = score[:]
t.append(P[qnum][n])
ret = min(ret, f(P, D, qnum+1, trial+n, d, t))
d[(qnum, trial, sum(score))] = ret
return ret
print((f(P, D, 0, 0, d)))
|
import sys
from collections import defaultdict
input = sys.stdin.readline
D, G = [int(x) for x in input().strip().split()]
P = [''] * D
for d in range(D):
p, c = [int(x) for x in input().strip().split()]
P[d] = [0] + [(d + 1) * 100 * (i + 1) for i in range(p)]
P[d][-1] += c
d = defaultdict(int)
def f(P, D, qnum, trial, d, flag=False, score=[]):
if (qnum, trial, sum(score)) in d:
return d[(qnum, trial, sum(score))]
#print('qnum={}, trial={}, score={}'.format(qnum,trial,score))
if qnum == D:
if sum(score) >= G:
#print(' OK : {}'.format(trial))
return trial
else:
#print(' NG')
return 10 ** 9 + 7
ret = 10 ** 9 + 7
if flag:
N = [0, len(P[qnum])-1]
else:
N = list(range(len(P[qnum])))
for n in N:
flag2 = flag
t = score[:]
t.append(P[qnum][n])
if not flag and n != len(P[qnum]) - 1 and n != 0:
flag2 = True
ret = min(ret, f(P, D, qnum+1, trial+n, d, flag2, t))
d[(qnum, trial, sum(score))] = ret
return ret
print((f(P, D, 0, 0, d)))
|
p03290
|
import itertools
from collections import Counter
D, G = list(map(int, input().split()))
P = [list(map(int, input().split())) for i in range(D)]
min_num = 10**8
judge_list = list(itertools.product([0, 1, 2], repeat=D)) #0:中途半端に解く 1:一問も解かない 2: 全部解く
for judge in judge_list:
score = 0
num = 0
d = Counter() #インスタンスを生成
d.update(judge)
if (d[0] <= 1):
for i in range(1, len(judge) + 1):
if score >= G:
break
if judge[-i] == 1:
pass
if judge[-i] == 2:
score += P[-i][0] * (D - i + 1) * 100 + P[-i][1]
num += P[-i][0]
if (judge[-i] == 0):
for j in range(P[-i][0]):
if score >= G:
break
score += 100 * (D - i + 1)
num += 1
if score >= G:
min_num = min(num, min_num)
print(min_num)
|
import itertools
D, G = list(map(int, input().split()))
L = [list(map(int, input().split())) for _ in range(D)]
num = D #生成するビット数
bit_list = list(itertools.product([0, 1], repeat=num))
tmp = 10 ** 6
for bit in bit_list:
count = 0
num = 0
for i in range(D):
if bit[i] == 1:
count += L[i][0] *(i+1) * 100 + L[i][1]
num += L[i][0]
if count >= G:
tmp = min(num, tmp)
else:
for i in range(1, D+1):
if bit[D-i] == 0:
for j in range(L[D-i][0]):
count += (D-i+1) * 100
num += 1
if count >= G:
break
break
if count >= G:
tmp = min(num, tmp)
print(tmp)
|
p03290
|
import itertools
D, G = list(map(int, input().split()))
L = [list(map(int, input().split())) for _ in range(D)]
num = D #生成するビット数
bit_list = list(itertools.product([0, 1], repeat=num))
tmp = 10 ** 6
for bit in bit_list:
count = 0
num = 0
for i in range(D):
if bit[i] == 1:
count += L[i][0] *(i+1) * 100 + L[i][1]
num += L[i][0]
if count >= G:
tmp = min(num, tmp)
else:
for i in range(1, D+1):
if bit[D-i] == 0:
for j in range(L[D-i][0]):
count += (D-i+1) * 100
num += 1
if count >= G:
break
break
if count >= G:
tmp = min(num, tmp)
print(tmp)
|
import itertools
def solve(D, G, problems):
bit_list = list(itertools.product([0, 1], repeat=D))
result_count = 10 ** 8
for pattern in bit_list:
score = 0 # スコアの合計
count = 0 # 解いた問題数
for i in range(D):
if pattern[i] == 1: # ビット値が１の難易度の問題は全て解く
score += problems[i][0] * (i+1) * 100 + problems[i][1] # 問題のスコア + ボーナス点
count += problems[i][0]
else:
max_score_problem = i
# 合計スコアが足りない場合，もっともスコアの高い未着手の問題を必要な分だけ解く
if score < G:
for i in range(problems[max_score_problem][0]):
count += 1
score += (max_score_problem + 1) * 100
if score >= G:
break
if score >= G:
result_count = min(result_count, count)
print(result_count)
if __name__ == '__main__':
D, G = list(map(int, input().split()))
problems = [list(map(int, input().split())) for _ in range(D)]
solve(D, G, problems)
|
p03290
|
D, G= list(map(int, input().split()))
P = [[int(x) for x in input().split()] for d in range(D)]
Score = [[] for d in range(D)]
for d in range(D):
for i in range(P[d][0] + 1):
Score[d].append(100 * (d + 1) * i)
Score[d][-1] += P[d][1]
DP = [[] for d in range(D)]
DP[0] = [x for x in Score[0]]
p_all = P[0][0]
for d in range(1, D):
p_all += P[d][0]
DP[d] = [0 for i in range(p_all + 1)]
for p in range(p_all + 1):
for s in range(min(P[d][0], p) + 1):
if p - s < p_all - P[d][0] + 1:
DP[d][p] = max(Score[d][s] + DP[d - 1][p - s], DP[d][p])
for i, s in enumerate(DP[D - 1]):
if s >= G:
print(i)
break
|
D, G = list(map(int, input().split()))
S = [[0] for i in range(D + 1)]
B = [[0] for i in range(D + 1)]
sumP = 0
for i in range(D):
p, c = list(map(int, input().split()))
S[i + 1] += [0] * (len(S[i]) + p - 1)
B[i + 1] += [100 * (i + 1) * (x + 1) for x in range(p)]
B[i + 1][-1] += c
for i in range(1, D + 1):
for j in range(1, len(S[i])):
for k in range(max(j - len(S[i - 1]) + 1, 0), min(len(B[i]), j + 1)):
S[i][j] = max(B[i][k] + S[i - 1][j - k], S[i][j])
for i, s in enumerate(S[D]):
if s >= G:
print(i)
break
|
p03290
|
import sys
sys.setrecursionlimit(100000)
inf = float('inf')
def dfs(h, s):
# 停止条件
if h == D:
tmp = 0
p = 0
ans = 0
for i, c in enumerate(s):
if c == '0':
tmp = i
else:
ans += pc[i][0]
p += (i+1) * 100 * pc[i][0] + pc[i][1]
for i in range(pc[tmp][0]-1):
if p < G:
p += (tmp + 1) * 100
ans += 1
if p < G:
return inf
else:
return ans
tmp1 = dfs(h+1, s + '0')
tmp2 = dfs(h+1, s + '1')
return min(tmp1, tmp2)
D, G = list(map(int, input().split()))
pc = [list(map(int, input().split())) for _ in range(D)]
print((dfs(0, '')))
|
D, G=list(map(int, input().split()))
PC=[0]+[list(map(int, input().split())) for _ in range(D)]
def function(G, i):
if i==0:
return 1e9
n=min(G//(i*100), PC[i][0])
s=n*i*100
if n==PC[i][0]:
s+=PC[i][1]
if s<G:
n+=function(G-s, i-1)
return min(n, function(G,i-1))
print((function(G, D)))
|
p03290
|
D, G = list(map(int, input().split()))
pc = [[i + 1] + [int(x) for x in input().split()] for i in range(D)]
import math
m = {}
def f(cur, n, left):
if left <= 0:
return n
def g(cur, n, left):
if cur in m: return m[cur]
r = m[cur] = f(cur, n, left)
return r
ret = 10**9
for x in pc:
i, p, c = x
if (1 << i) & cur: continue
ip = i*100*p
if ip > left:
h = math.ceil(left / (i*100))
ret = min(ret, n + h)
else:
if n + p >= ret: continue
h = f(cur | (1 << i), n + p, left - ip - c)
ret = min(ret, h)
return ret
print((f(0, 0, G)))
|
D, G = list(map(int, input().split()))
pc = [[i + 1] + [int(x) for x in input().split()] for i in range(D)]
import math
m = {}
def f(cur, n, left):
if left <= 0:
return n
def g(cur, n, left):
if cur in m: return m[cur]
r = m[cur] = f(cur, n, left)
return r
ret = 10**9
for x in pc:
i, p, c = x
if (1 << i) & cur: continue
ip = i*100*p
if ip > left:
h = math.ceil(left / (i*100))
ret = min(ret, n + h)
else:
if n + p >= ret: continue
h = g(cur | (1 << i), n + p, left - ip - c)
ret = min(ret, h)
return ret
print((f(0, 0, G)))
|
p03290
|
def solve():
inf = 1 << 60
D, G = list(map(int, input().split()))
p = [0]
c = [0]
for i in range(D):
pi, ci = list(map(int, input().split()))
p.append(pi)
c.append(ci)
sump = sum(p)
# dp[i][j] = 100i点の問題までで、j問解いて得られる最大の点数
dp = [[-inf for j in range(sump+1)] for i in range(D+1)]
dp[0][0] = 0
for d in range(1,D+1):
for i in range(sump+1):
for j in range(p[d]+1):
if i - j >= 0:
dp[d][i] = max(dp[d][i], dp[d-1][i])
if dp[d-1][i-j] >= 0:
if j != p[d]:
dp[d][i] = max(dp[d][i], dp[d-1][i-j] + 100*d*j)
else:
dp[d][i] = max(dp[d][i], dp[d-1][i-j] + 100*d*j+c[d])
#print(dp)
for i in range(sump+1):
if dp[D][i] >= G:
return i
print((solve()))
|
def solve():
inf = 1 << 60
D, G = list(map(int, input().split()))
p = []
c = []
for i in range(D):
pi, ci = list(map(int, input().split()))
p.append(pi)
c.append(ci)
bitD = 1 << D
min_cnt = inf
for b in range(bitD):
sc = 0
cnt = 0
for i in range(D):
if (b & (1 << i)) != 0:
sc += (i + 1) * 100 * p[i] + c[i]
cnt += p[i]
if sc < G:
for i in range(D-1,-1,-1):
if (b & (1 << i)) == 0:
unit = (i + 1) * 100
cnt2 = min((G - sc + (unit - 1)) // unit, p[i] - 1)
sc += cnt2 * unit
cnt += cnt2
break
if sc >= G:
min_cnt = min(min_cnt, cnt)
return min_cnt
print((solve()))
|
p03290
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
D, G = list(map(int, input().split()))
P = [] * D
C = [] * D
for i in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
ans = float('inf')
for i in range(1<<D):
total = 0
num = 0
for j in range(D):
if ((i >> j) & 1):
total += C[j] + 100*P[j]*(j+1)
num += P[j]
# print(total, num)
if total >= G:
ans = min(ans, num)
else:
for j in range(D-1, -1, -1):
if ((i >> j) & 1):
continue
# print('i=', i)
# print('j=',j)
# print('-', total, num)
for k in range(P[j]-1):
if total >= G:
break
# print('?', total, num)
# print('k=', k)
total += 100*(j+1)
num += 1
# print('?', total, num)
# print('Z', total, num, ans)
# print('----')
if total >= G:
# print('x', total, num, ans)
ans = min(ans, num)
print(ans)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
D, G = list(map(int, input().split()))
P = [] * D
C = [] * D
for i in range(D):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c)
ans = float('inf')
for i in range(1<<D):
total = 0
num = 0
for j in range(D):
if ((i >> j) & 1):
total += C[j] + 100*P[j]*(j+1)
num += P[j]
if total >= G:
ans = min(ans, num)
else:
for j in range(D-1, -1, -1):
if ((i >> j) & 1):
continue
for k in range(P[j]-1):
if total >= G:
break
total += 100*(j+1)
num += 1
if total >= G:
ans = min(ans, num)
print(ans)
|
p03290
|
from itertools import product
D, G = list(map(int, input().split()))
score = []
for i in range(D):
p, c = list(map(int, input().split()))
s = (i + 1) * 100
score.append([s, p, c, s * p + c])
ans = float('inf')
for ptn in product([0, 1], repeat=D):
total = 0
cnt = 0
for i in range(D):
total += score[i][3] * ptn[i]
cnt += score[i][1] * ptn[i]
if 0 in ptn[::-1]:
i = D - 1 - ptn[::-1].index(0)
x = score[i]
else:
x = score[-1]
for i in range(x[1]):
if total >= G:
break
total += x[0]
cnt += 1
if total < G:
cnt = float('inf')
ans = min(ans, cnt)
print(ans)
|
from itertools import product
D, G = list(map(int, input().split()))
pc = [[int(x) for x in input().split()] for _ in range(D)]
C = [0] * D
for i in range(D):
p, c = pc[i]
C[i] = 100 * (i + 1) * p + c
ans = float('inf')
for ptn in product([0, 1], repeat=D):
point, cnt = 0, 0
for i in range(D):
p, c = pc[i]
cnt += p * ptn[i]
point += C[i] * ptn[i]
if 0 in ptn:
index = D - 1 - ptn[::-1].index(0)
p, _ = pc[index]
for i in range(p):
if point >= G:
break
point += 100 * (index + 1)
cnt += 1
if point >= G:
ans = min(ans, cnt)
print(ans)
|
p03290
|
D, G = list(map(int, input().split()))
dic = [0]*(D+1)
for i in range(D):
p, c = list(map(int, input().split()))
dic[i+1] = (p,c)
ans = 10**9
for i in range(2**D):
ls = []
x = i
v = 0
count = 0
for j in range(D):
if x%2==1:
ls += [j+1]
x = x>>1
for h in ls:
p, c = dic[h]
v += p*h*100 + c
count += p
if G>v:
for j in range(D, 0, -1):
if not j in ls:
break
else:
continue
m = dic[j][0]
while m>1:
v += j*100
count += 1
m -= 1
if v>=G:
break
else:
continue
if count<ans:
ans = count
print(ans)
|
D, G, *L = list(map(int, open(0).read().split()))
inf = []
for m in zip(*[iter(L)]*2):
inf.append(m)
ans = float('inf')
for i in range(2**D):
m = 0
cnt = 0
log = []
for j in range(D):
if i%2==0:
m += 100*(j+1)*inf[j][0]+inf[j][1]
cnt += inf[j][0]
else:
log.append(j)
i>>=1
while m<G:
if log==[]:
break
h = log.pop()
s = 100*(h+1)
x = (G-m)//s if (G-m)%s==0 else (G-m)//s+1
c = min(inf[h][0]-1, x)
m += c*s
cnt += c
else:
ans = min(ans,cnt)
print(ans)
|
p03290
|
D,G = list(map(int,input().split()))
pc = [list(map(int,input().split())) for i in range(D)]
#print(pc)
ans = float("inf")
for i in range(2**D):
sum = 0
count = 0
rem = set(range(1,D+1))
for j in range(D):
if (i >> j) & 1:
sum += pc[j][0]*100*(j+1)+pc[j][1]
count += pc[j][0]
rem.discard(j+1)
if sum < G:
k = max(rem)-1
n = min(pc[k][0],-(-(G-sum)//((k+1)*100)))
count += n
sum += n*100*(k+1)
if sum >= G:
ans = min(ans,count)
print(ans)
|
def dfs (i,sum,count,rem):
global ans
if i == D:
if sum < G:
k = max(rem)
n = min(pc[k-1][0],-(-(G-sum)//(k*100)))
count += n
sum += n*100*k
if sum >= G:
ans = min(ans,count)
else:
dfs(i+1,sum,count,rem)
dfs(i+1,sum+pc[i][0]*100*(i+1)+pc[i][1],count+pc[i][0],rem-{i+1})
D,G = list(map(int,input().split()))
pc = [list(map(int,input().split())) for i in range(D)]
ans = float("inf")
dfs(0,0,0,set(range(1,D+1)))
print(ans)
|
p03290
|
from copy import copy
D,G=list(map(int,input().split()))
p=[]
c=[]
for i in range(D):
a,b=list(map(int,input().split()))
p.append(a)
c.append(b)
lst1=[]
lst2=[]
lst3=[]
def func1(l1,l2,l3,p,c,G):
S=0
n=0
ind=0
for i in range(len(l1)):
S+=c[i]*l1[i]
n+=p[i]*l1[i]
S+=p[i]*100*(i+1)*l1[i]
for i in range(len(l2)):
if S>=G:
break
kazu=len(l2)-i
a=l2[kazu-1]
for j in range(1,a+1):
if j==a:
break
S+=100*kazu
n+=1
if S>=G:
break
if S>=G:
l3.append(n)
l3.append(S)
return 0
def func(l1,l2,l3,num,p,c,G):
if num==0:
func1(l1,l2,l3,p,c,G)
return 0
y1=copy(l2)
y2=copy(l2)
y2[len(l1)]=0
x1=copy(l1)
x1.append(0)
x2=copy(l1)
x2.append(1)
num-=1
return func(x1,y1,l3,num,p,c,G),func(x2,y2,l3,num,p,c,G)
func(lst1,p,lst3,D,p,c,G)
print((min(lst3)))
|
from math import ceil
D,G=list(map(int,input().split()))
P=[]
C=[]
R=[]
for i in range(D):
p,c=list(map(int,input().split()))
P.append(p)
C.append(c)
R.append((i+1)*100*p+c)
bit=2**D
ans=10**19
for i in range(bit):
i=bin(i)[2:].zfill(D)
su=0
num=0
k=-1
for j in range(D):
k=int(i[j])
su+=k*R[j]
num+=k*P[j]
if k==0:
t=j
if G<=su:
ans=min(ans,num)
continue
if k==-1:
continue
if ceil((G-su)/((t+1)*100))<P[t]:
ans=min(ans,num+ceil((G-su)/((t+1)*100)))
print(ans)
|
p03290
|
#### import ####
import sys
import math
from collections import defaultdict
#### 設定 ####
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
#### 定数 ####
mod = 10**9 + 7
#### 読み込み ####
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
D,G = II()
p,c = Line(D)
def dfs(point,p):
if point<=0:
return 0
else:
ret = []
for i in range(D):
if p[i]==0:
continue
num = math.ceil(point/((i+1)*100))
if num <= p[i]:
ret.append(num)
else:
temp = p[i]
p[i] = 0
ret.append(dfs(point-100*(i+1)*temp-c[i],p)+temp)
p[i] = temp
return min(ret)
print((dfs(G,p)))
|
#### import ####
import sys
import math
from collections import defaultdict
#### 設定 ####
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
#### 定数 ####
mod = 10**9 + 7
#### 読み込み ####
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
D,G = II()
p,c = Line(D)
def dfs(point,p):
if point<=0:
return 0
else:
ret = []
for i in range(D):
if p[i]==0:
continue
q,mod = divmod(point,(i+1)*100)
if mod ==0:
num = q
else:
num = q+1
if num <= p[i]:
ret.append(num)
else:
temp = p[i]
p[i] = 0
ret.append(dfs(point-100*(i+1)*temp-c[i],p)+temp)
p[i] = temp
return min(ret)
print((dfs(G,p)))
|
p03290
|
d,g = list(map(int,input().split()))
P,C = [],[]
for i in range(1, d+1):
p,c = list(map(int,input().split()))
P.append(p)
C.append(c)
ans = 10**9
for bin in range(1, 1<<d):
cnt = tot = 0
for j in range(d):
if bin & 1<<j:
cnt += P[j]
tot += P[j]*(j+1)*100 + C[j]
if tot < g: continue
ans = min(ans, cnt)
for j in range(d):
if bin & 1<<j:
now_cnt = cnt
now_tot = tot - C[j]
for k in range(P[j]-1):
now_cnt -= 1
now_tot -= (j+1)*100
if now_tot >= g: ans = min(ans, now_cnt)
print(ans)
|
d,g = list(map(int,input().split()))
g //= 100
P,C = [],[]
for i in range(1, d+1):
p,c = list(map(int,input().split()))
P.append(p)
C.append(c//100)
ans = 10**9
# print(P)
# print(C)
for bin in range(1, 1<<d):
cnt = tot = 0
for j in range(d):
if bin & 1<<j:
cnt += P[j]
tot += P[j]*(j+1) + C[j]
if tot < g: continue
ans = min(ans, cnt)
# print('tot',tot, end=' ')
# print('cnt',cnt, end='\n')
for j in range(d):
if bin & 1<<j:
init_cnt = cnt - P[j]
init_tot = tot - (P[j]*(j+1) + C[j])
rest_g = g - init_tot
k = max(0, (rest_g+j)//(j+1)) # round up, required quantity
# print('Pj',P[j], end=' ')
# print('Cj',C[j], end=' ')
# print('init_cnt',init_cnt, end=' ')
# print('init_tot',init_tot, end=' ')
# print('rest_g',rest_g, end=' ')
# print('k',k, end='\n')
if k < P[j]:
# ans = init_cnt + k
ans = min(ans, init_cnt + k)
# print('init_cnt+k',init_cnt+k, end='\n')
print(ans)
|
p03290
|
d,g = list(map(int,input().split()))
P,C = [0]*d,[0]*d
for i in range(d): P[i],C[i] = list(map(int,input().split()))
ans = 10**9
for bin in range(1, 1<<d):
cnt = tot = 0
for i in range(d):
if bin & 1<<i:
cnt += P[i]
tot += P[i]*(i+1)*100 + C[i]
if tot < g: continue
ans = min(ans, cnt)
for i in range(d):
if bin & 1<<i:
now_cnt = cnt
now_tot = tot - C[i]
for k in range(P[i]-1):
now_cnt -= 1
now_tot -= (i+1)*100
if now_tot >= g: ans = min(ans, now_cnt)
print(ans)
|
d,g = list(map(int,input().split()))
g //= 100
P,C = [0]*d,[0]*d
for i in range(d):
P[i],C[i] = list(map(int,input().split()))
C[i] //= 100
ans = 10**9
for bin in range(1, 1<<d):
cnt = tot = 0
for i in range(d):
if bin & 1<<i:
cnt += P[i]
tot += P[i]*(i+1) + C[i]
if tot < g: continue
ans = min(ans, cnt)
for i in range(d):
if bin & 1<<i:
rest_g = g - (tot - P[i]*(i+1) - C[i])
p = max(0, (rest_g+i)//(i+1)) # round up
ans = min(ans, cnt - (P[i] - p))
print(ans)
|
p03290
|
d,g = list(map(int,input().split()))
P,C = [0]*d,[0]*d
for i in range(d): P[i],C[i] = list(map(int,input().split()))
ans = 10**9
for bin in range(1, 1<<d):
cnt = tot = 0
for i in range(d):
if bin & 1<<i:
cnt += P[i]
tot += P[i]*(i+1)*100 + C[i]
if tot < g: continue
ans = min(ans, cnt)
for i in range(d):
if bin & 1<<i:
t = (i+1)*100
rest_g = g - (tot - P[i]*t - C[i])
p = max(0, (rest_g+t-1)//t) # round up
ans = min(ans, cnt - (P[i] - p))
print(ans)
|
d,g = list(map(int,input().split()))
P,C = [0]*d,[0]*d
for i in range(d): P[i],C[i] = list(map(int,input().split()))
ans = 10**9
for bin in range(0, 1<<d):
cnt = tot = 0
rest_max_bit = -1
for i in range(d):
if bin & 1<<i:
t = (i+1)*100
tot += P[i]*t + C[i]
cnt += P[i]
else: rest_max_bit = i
if tot >= g:
ans = min(ans, cnt)
continue
if rest_max_bit < 0: continue
t = (rest_max_bit+1)*100
rest_g = g - tot
p = min(P[rest_max_bit]-1, (rest_g+t-1)//t) # [0,pi-1]
if p*t >= rest_g: ans = min(ans, cnt + p)
print(ans)
|
p03290
|
d,g = list(map(int,input().split()))
P,C = [0]*d,[0]*d
for i in range(d): P[i],C[i] = list(map(int,input().split()))
ans = 10**9
for bin in range(1<<d):
cnt = tot = rest_max_bit = 0
for i in range(d):
if bin & 1<<i:
t = (i + 1)*100
tot += P[i]*t + C[i]
cnt += P[i]
else: rest_max_bit = i
if tot < g:
t = (rest_max_bit + 1)*100
p = (g - tot + t - 1)//t
if p >= P[rest_max_bit]: continue
cnt += p
ans = min(ans, cnt)
print(ans)
|
d, g = list(map(int,input().split()))
data = [list(map(int,input().split())) for _ in range(d)]
def dfs(d, rest): # difficulty, rest score
if d <= 0: return 10**9
num, bonus = data[d-1] # num of problems, bonus
# now, use or don't use difficulty d?
use = min(rest//(d*100), num) # num when use
score = use * d * 100 # score when use
if use == num: score += bonus # ?perfect
if rest - score > 0: # ?rest
use += dfs(d-1, rest - score) # rest of score -> recursion
not_use = dfs(d-1, rest) # num when don't use -> recursion
return min(use, not_use)
print((dfs(d, g)))
|
p03290
|
D, G = list(map(int, input().split()))
pc = []
for n in range(D):
p, c = list(map(int, input().split()))
pc.append([p, c, p * (n + 1)*100 + c])
ans = sum(pc[:][0])
for i in range(2 ** D):
temp = 0
numberProb = 0
box = ["-"] * D
for j in range(D):
if ((i >> j) & 1):
box[D - j - 1] = "+"
for k, l in enumerate(box):
if l == "+":
temp += pc[k][2]
numberProb += pc[k][0]
if temp >= G:
ans = min(ans, numberProb)
else:
lisind = max( [i for i, x in enumerate(box) if x == '-'])
for m in range(pc[lisind][0]):
temp += (lisind + 1) * 100
numberProb += 1
if temp >= G:
ans = min(ans, numberProb)
break
print(ans)
|
D, G = list(map(int, input().split()))
pc = [list(map(int, input().split())) for _ in range(D)]
# 大問D問中のn問といてG点以上をとる最低の問題数n
ans = int(1e10)
for i in range(2 ** D):
zen = []
atemp = 0
ktemp = 0
for j in range(D):
if (i >> j) & 1:
zen.append(True)
else:
zen.append(False)
for n, tf in enumerate(zen):
if tf:
atemp += pc[n][0] * (n+1) * 100 + pc[n][1]
ktemp += pc[n][0]
else:
hanpa = n
if atemp >= G:
ans = min(ans, ktemp)
else:
if atemp + pc[hanpa][0]*(hanpa+1)*100 < G:
continue
else:
if (G - atemp) % ((hanpa+1)*100) == 0:
ans = min(ans, ktemp + ((G - atemp) // ((hanpa+1)*100)))
else:
ans = min(ans, ktemp + ((G - atemp) // ((hanpa+1)*100)) + 1)
print(ans)
|
p03290
|
#ABC 104 C - All Green
#順列総当たりでやる
import itertools
d, g = list(map(int, input().split()))
#print(d)
p=[]
c=[]
ld = []
for i in range(d):
pk, ck = list(map(int, input().split()))
p.append(pk)
c.append(ck)
ld.append(i)
jun = list(itertools.permutations(ld))
ans=10000
for j in jun:
#順列の数だけ試す。j[番号]で調べてる順列の番号番目の数を返す
ten = 0
mondaisu = 0
for k in range(d):
bango = j[k]
katen = (bango + 1)*100*p[bango] + c[bango]
# print("n問目"+str(bango +1) + "加点"+ str(katen))
if ten + katen > g:
nokori = ((g-ten)-1)//((bango + 1)*100) + 1
if nokori > p[bango]:#ボーナス点がないと届かない場合
mondaisu += p[bango]
else:
mondaisu += nokori
break
else:
ten += katen
mondaisu += p[bango]
if ans > mondaisu:
ans = mondaisu
# print(str(j) + "問題数" + str(mondaisu) +"答えリスト")
# print(ans_list)
print(ans)
#print(jun[0][1])
#print(p)
#print(c)
|
#ABC 104 C - All Green
#ビット総当たりでやる
d, g = list(map(int, input().split()))
#print(d)
p=[]
c=[]
for i in range(d):
pk, ck = list(map(int, input().split()))
p.append(pk)
c.append(ck)
#print(p)
#print(c)
ans = 10000#仮の答え
#2^d通り試す
for i in range(2 ** d):
#右からn番目の桁が1→n+1の配点の問題を完全に解く
ten = 0
mondaisu = 0
for j in range(d):
if (i>>j)&1 == 1:
#p[j]個あるj+1の配点の問題を完全に解く
ten += (j+1)*100*p[j] + c[j]
mondaisu += p[j]
else:
#p[j]個あるj+1の配点の問題は完全にとかない
k = j
#フラグの立った配点の問題を全部といた
if ten > g:
if ans > mondaisu:
ans = mondaisu
else:
#中途半端に解かないと行けない場合p[k]の問題を中途半端に解く
if g-ten <= (k+1)*100*p[k] :
mondaisu += (g-ten-1)//((k+1)*100) +1
if ans > mondaisu:
ans = mondaisu
#中途半端に解いて届かない場合スルー
# print(mondaisu)
print(ans)
|
p03290
|
d,g = list(map(int,input().split()))
p_input = [0]*d
c_input = [0]*d
for i in range(d):
p_input[i],c_input[i] = list(map(int,input().split()))
ans=float('inf')
for i in range(2**d):
problem=0
point=0
for j in range(d):
if ((i>>j)&1):
problem+=p_input[j]
point+=(1+j)*100*p_input[j]+c_input[j]
if point>=g:
ans=min(ans,problem)
else:
for j in range(d-1,-1,-1):
if ((i>>j)&1):
continue
for k in range(p_input[j]):
if point>=g:
break
problem+=1
point+=100*(j+1)
ans = min(ans,problem)
print(ans)
|
d,g = list(map(int,input().split()))
P = [0]*d
C = [0]*d
for i in range(d):
P[i],C[i] = list(map(int,input().split()))
ans = float('inf')
for i in range(2**d):
tmp = 0
res = 0
for j in range(d):
if ((i>>j)&1):
tmp+=C[j]+(j+1)*100*P[j]
res+=P[j]
if tmp<g:
for j in range(d-1,-1,-1):
if not ((i>>j)&1):
if tmp>=g:
break
if tmp+(j+1)*100*P[j]<=g:
tmp+=(j+1)*100*P[j]
res+=P[j]
else:
for p in range(P[j]):
if tmp>=g:
break
tmp+=(j+1)*100
res+=1
ans = min(ans,res)
print(ans)
|
p03290
|
import functools
D, G = list(map(int, input().split()))
G = G // 100
sumn = 0
ns = [0] * (D + 1)
cs = [0] * (D + 1)
for i in range(1, D + 1):
n, c = list(map(int, input().split()))
ns[i] = n
cs[i] = c // 100
sumn += n
minn = [0] * (D + 1)
for i in range(1, D + 1):
minn[i] = min(ns[1:i+1])
@functools.lru_cache(maxsize=None)
def f(i, rn):
if i == 1:
if ns[1] < rn:
return -1
p = rn
if ns[1] == rn:
p += cs[1]
return p
if rn < minn[i]:
p = 0
for j in range(i, 0, -1):
n = min((ns[j], rn))
p += j * n
if n == rn:
break
rn -= n
return p
maxp = 0
for n in range(min((ns[i], rn)) + 1):
p = i * n
if n == ns[i]:
p += cs[i]
np = f(i - 1, rn - n)
if np >= 0:
p += np
if maxp < p:
maxp = p
return maxp
mn = 1
mx = sumn
while mn < mx:
x = mn + ((mx - mn) // 2)
if G <= f(D, x):
mx = x
else:
mn = x + 1
print(mn)
|
from itertools import combinations
D, G = list(map(int, input().split()))
G = G // 100
ns = [0] * (D + 1)
cs = [0] * (D + 1)
for i in range(1, D + 1):
n, c = list(map(int, input().split()))
ns[i] = n
cs[i] = c // 100
ans = sum(ns)
for partialsn in range(1, D + 1):
for partials in combinations(list(range(1, D + 1)), partialsn):
sumn = 0
rp = G
for i in range(1, D + 1):
if not i in partials:
sumn += ns[i]
rp -= i * ns[i] + cs[i]
if rp > 0:
for i in sorted(partials, reverse=True):
n = ns[i] - 1
if rp <= i * n:
n = rp // i
if rp % i != 0:
n += 1
sumn += n
rp -= i * n
if rp <= 0:
break
if rp <= 0:
if sumn < ans:
ans = sumn
print(ans)
|
p03290
|
inf = float('inf')
def rec(cur, partially_solved, solve_num, score):
if cur == d:
return solve_num if score >= g else inf
res = rec(cur + 1, partially_solved, solve_num, score)
res = min(res,
rec(cur + 1, partially_solved, solve_num + p[cur], score + p[cur] * (cur + 1) * 100 + c[cur]))
if not partially_solved:
for i in range(1, p[cur]):
res = min(res,
rec(cur + 1, True, solve_num + i, score + i * (cur + 1) * 100))
return res
d, g = list(map(int, input().split()))
p, c = [], []
for _ in range(d):
tp, tc = list(map(int, input().split()))
p.append(tp)
c.append(tc)
print((rec(0, False, 0, 0)))
|
def main():
from itertools import product
D, G = list(map(int, input().split()))
prob = []
for j in range(1, D + 1):
p, c = list(map(int, input().split()))
prob.append((j * 100, p, c)) # score,amount,bonus
ans = -1
for prd in product([0, 1], repeat=D):
cnt = 0
g = 0
for j, (score, amount, bonus) in zip(prd, prob):
if j:
cnt += amount
g += score * amount + bonus
if g < G:
for j, (score, amount, bonus) in reversed(tuple(zip(prd, prob))):
if (not j) and (score * amount >= G - g):
use = (G - g + score - 1) // score
cnt += use
g += score * use
break
if (g < G) or (~ans and ans <= cnt): continue
ans = cnt
print(ans)
if __name__ == '__main__':
main()
|
p03290
|
#!/mnt/c/Users/moiki/bash/env/bin/python
D,G = list(map(int, input().split()))
points = [ [int(j) for j in input().split()] for _ in range(D)]
points = [ [x[0], x[1], 100*e*x[0]] for e,x in enumerate(points, 1)]
ans = float("inf")
for i in range(1<<D): # for complete bonus bit set
lg = G
cnt = 0
for d in range(D):
if i & (1<<d) != 0:
lg -= points[d][1] # complete bonus
lg -= (100*(d+1))*points[d][0] # normal points
cnt += points[d][0]
if lg <= 0:
break
if lg <= 0:
ans = min(ans, cnt)
continue
# other points
for d in range(D-1, -1, -1):
if i & (1<<d) != 0: continue
if lg <= points[d][2]:
quot = (lg+(100*(d+1)-1)) // (100*(d+1))
lg -= 100*(d+1)*quot
cnt += quot; break
else:
cnt += points[d][0]
lg -= 100*(d+1)*points[d][0]
cnt += points[d][0]
if lg <= 0:
ans = min(ans, cnt)
continue
print(ans)
|
#!/mnt/c/Users/moiki/bash/env/bin/python
D,G = list(map(int, input().split()))
points = [ [int(j) for j in input().split()] for _ in range(D)]
points = [ [x[0], x[1], 100*e*x[0]] for e,x in enumerate(points, 1)]
ans = float("inf")
for i in range(1<<D): # for complete bonus bit set
lg = G
cnt = 0
for d in range(D):
if i & (1<<d) != 0:
lg -= points[d][1] # complete bonus
# lg -= (100*(d+1))*points[d][0] # normal points
lg -= points[d][2] # normal points
cnt += points[d][0]
if lg <= 0:
break
if lg <= 0:
ans = min(ans, cnt)
continue
# other points
for d in range(D-1, -1, -1):
if i & (1<<d) != 0: continue
if lg <= points[d][2]:
quot = (lg+(100*(d+1)-1)) // (100*(d+1)) # carryUp
lg -= 100*(d+1)*quot
cnt += quot; break
else:
cnt += points[d][0]
lg -= points[d][2]
if lg <= 0:
ans = min(ans, cnt)
continue
print(ans)
|
p03290
|
D, G = list(map(int, input().split()))
pc = [tuple(map(int, input().split())) for _ in range(D)]
memo = dict()
def rec(crp, crscore, crans):
global D, G, pc, memo
if (crp, crscore) in memo:
return memo[(crp, crscore)] + crans
if crscore >= G:
return crans
elif crp > D:
return 10**9
p, c = pc[crp - 1]
tmp_min = min(
rec(crp + 1, crscore + 100 * crp * i, crans + i) for i in range(p)
)
res = min(tmp_min, rec(crp + 1, crscore + 100 * crp * p + c, crans + p))
memo[(crp, crscore)] = res - crans
return res
print((rec(1, 0, 0)))
|
from itertools import product
D, G = list(map(int, input().split()))
pc = [tuple(map(int, input().split())) for _ in range(D)]
ans = 1e9
for selected in product((True, False), repeat=D):
tmp_score = 0
tmp_count = 0
rest_max = 0
for i, is_select in enumerate(selected):
if is_select:
tmp_score += 100 * (i + 1) * pc[i][0] + pc[i][1]
tmp_count += pc[i][0]
else:
rest_max = i
if tmp_score < G:
s1 = 100 * (rest_max + 1)
need = (G - tmp_score + s1 - 1) // s1
if need >= pc[rest_max][0]:
continue
tmp_count += need
ans = min(ans, tmp_count)
print(ans)
|
p03290
|
d,g=list(map(int,input().split()))
spc=[]
c=[]
for i in range(d):
pi,ci=list(map(int,input().split()))
si=pi*100*(i+1)+ci
av=si//pi
spc.append([av,si,pi,ci,100*(i+1)])
#print(spc)
spc.sort(reverse=True)
#print(spc)
#r=g
#icnt=0
#for i in range(d):
# r=r-spc[i][1]
# icnt=icnt+spc[i][2]
# if r<=0:
# break
#print(r,icnt)
dmin=10000
for i in range(d):
for j in range(2**d):
# print("d=",d,"i=",i,"j=",j,j//2,j%2)
icnt=0
sisum=0
j2=j
for i2 in range(d):
if i2!=i:
if j2%2==1:
sisum=sisum+spc[i2][1]
icnt=icnt+spc[i2][2]
# if sisum>g:
# break
# print("j=",j,icnt,sisum)
j2=j2//2
for k in range(spc[i][2]):
sisum=sisum+spc[i][4]
icnt=icnt+1
# print("k",k,icnt,sisum)
if sisum>=g:
break
if k==spc[i][2]-1 :
sisum=sisum+spc[i][3]
# if sisum>=g :
# print("kend",icnt,sisum)
if sisum>=g and icnt<dmin :
dmin=icnt
# print("dmin=",dmin,sisum)
print(dmin)
|
import itertools
d,g=list(map(int,input().split()))
pc=[[0]*2 for i in range(d)]
for i in range(d):
pc[i]=list(map(int,input().split()))
icntmin=10*100+1
for j in itertools.product([0,1], repeat=d):
icnt=0
gcnt=0
for i in range(d):
if j[i]==1:
icnt+=pc[i][0]
gcnt+=pc[i][0]*100*(i+1)+pc[i][1]
else:
ii=i
# print("1",icnt,gcnt,j)
if gcnt>=g:
icntmin=min(icnt,icntmin)
continue
else:
gr=g-gcnt
k=(gr-1)//(100*(ii+1))+1
if k<pc[ii][0]:
icnt+=k
gcnt+=k*100*(ii+1)
icntmin=min(icnt,icntmin)
# print("2",icnt,gcnt,ii,gr,k,j)
print(icntmin)
|
p03290
|
# coding: utf-8
# Your code here!
ans = 10**9
def calc(point,num, i):
global ans
global G, D
if num > ans:
return
if point >= G:
if num < ans:
ans = num
return
if i >= D:
return
for j in range(problem[i][0]):
tmp = point
for k in range(i, D):
tmp += (k+1)*100*problem[k][0]+problem[k][1]
if tmp < G:
return
calc(point + (i+1) * 100 * j,num+j, i+1)
calc(point + (i+1) * 100 * problem[i][0] + problem[i][1],num+problem[i][0], i+1)
D, G=list(map(int, input().split()))
problem=[list(map(int,list(input().split()))) for i in range(D)]
calc(0,0,0)
print(ans)
|
# coding: utf-8
# Your code here!
from itertools import product
ans = 10**9
D, G=list(map(int, input().split()))
problem=[list(map(int,list(input().split()))) for i in range(D)]
for p in product([True, False], repeat=D):
point = 0
num = 0
for i in range(D):
if p[i]:
point += (i+1) * 100 * problem[i][0] + problem[i][1]
num += problem[i][0]
if point >= G:
ans = min(ans, num)
for i in reversed(list(range(D))):
if p[i] == False:
if point >= G:
ans = min(ans, num)
break
for j in range(problem[i][0]):
point += (i+1) * 100
num += 1
if point >= G:
break
if point >= G:
ans = min(ans, num)
print(ans)
|
p03290
|
# -*- coding: utf-8 -*-
from itertools import product
D, G = list(map(int, input().split()))
pc_table = [tuple(map(int, input().split())) for _ in range(D)]
bit_table = list(product([0, 1], repeat=D))
cnts = []
for bits in bit_table:
g = sum([
pc_table[i][1] + 100 * (i + 1) * pc_table[i][0]
for i, bit in enumerate(bits) if bit
])
cnt = sum([pc_table[i][0] for i, bit in enumerate(bits) if bit])
if g >= G:
cnts.append(cnt)
else:
max_p = max([i for i, bit in enumerate(bits) if not bit])
for _ in range(pc_table[max_p][0]):
g += 100 * (max_p + 1)
cnt += 1
if g >= G:
cnts.append(cnt)
break
print((min(cnts)))
|
# -*- coding: utf-8 -*-
from itertools import product
D, G = list(map(int, input().split()))
pc_table = [tuple(map(int, input().split())) for _ in range(D)]
bit_table = list(product([0, 1], repeat=D))
cnts = []
for bits in bit_table:
g = sum([
pc_table[i][1] + 100 * (i + 1) * pc_table[i][0]
for i, bit in enumerate(bits) if bit
])
cnt = sum([pc_table[i][0] for i, bit in enumerate(bits) if bit])
max_p = 0 if sum(bits) == D else max(
[i for i, bit in enumerate(bits) if not bit])
for _ in range(pc_table[max_p][0]):
if g >= G:
cnts.append(cnt)
break
else:
g += 100 * (max_p + 1)
cnt += 1
print((min(cnts)))
|
p03290
|
D, G = [int(item) for item in input().split()]
comp_bounas_list = [[int(item) for item in input().split()] for _ in range(D)]
comp_all = []
for i in range(2**D):
temp = []
for j in range(D):
if ((i >> j) & 1) == 1:
temp.append(1)
else:
temp.append(0)
comp_all.append(temp)
# print(comp_bounas_list)
# print(comp_all)
full_num_list = [item[0] for item in comp_bounas_list]
each_comp_point = []
for i, item in enumerate(comp_bounas_list):
each_comp_point.append((i+1)*100*item[0]+item[1])
# print(full_num_list)
# print(each_comp_point)
temp_point_list = []
for each_pattern in comp_all:
temp_num = 0
temp_point = 0
for j, item in enumerate(each_pattern):
if item:
temp_num += full_num_list[j]
temp_point += each_comp_point[j]
temp_point_list.append([temp_num, temp_point, each_pattern])
# print(temp_point_list)
# overの物を解候補にリスト化する
over_list = [item for item in temp_point_list if item[1] >= G]
# print(over_list)
over_combo = min(over_list, key = lambda x:x[0])
# print(over_combo)
# underのものを解候補にリスト化する
under_combo = [item for item in temp_point_list if item[1] < G]
# print(over_combo)
# print(under_combo)
temp_res_list = []
is_search = True
for temp_combo in under_combo:
temp_bit_list = temp_combo[2]
temp_res_point = temp_combo[1]
temp_res_num = temp_combo[0]
# print(temp_combo)
# print(temp_bit_list)
for j, item in reversed(list(enumerate(temp_bit_list))):
for _ in range(1, comp_bounas_list[j][0]):
# print(temp_res_point)
if item==0:
temp_res_point += (j+1)*100
temp_res_num += 1
if temp_res_point >= G:
temp_res_list.append([temp_res_num, temp_res_point])
break
# print(temp_res_list)
if temp_res_list != []:
res_candi = min(temp_res_list, key=lambda x:x[0])
else:
res_candi = temp_point_list[-1]
if over_combo[0] <= res_candi[0]:
print((over_combo[0]))
else:
print(( res_candi[0]))
|
# 以下ペースト可
D, G = [int(item) for item in input().split()]
comp_bounas_list = [[int(item) for item in input().split()] for _ in range(D)]
comp_all = []
for i in range(2**D):
temp = []
for j in range(D):
if ((i >> j) & 1) == 1:
temp.append(1)
else:
temp.append(0)
comp_all.append(temp)
# print(comp_bounas_list)
# print(comp_all)
full_num_list = [item[0] for item in comp_bounas_list]
each_comp_point = []
for i, item in enumerate(comp_bounas_list):
each_comp_point.append((i+1)*100*item[0]+item[1])
# print(full_num_list)
# print(each_comp_point)
temp_point_list = []
for each_pattern in comp_all:
temp_num = 0
temp_point = 0
for j, item in enumerate(each_pattern):
if item:
temp_num += full_num_list[j]
temp_point += each_comp_point[j]
temp_point_list.append([temp_num, temp_point, each_pattern])
# print(temp_point_list)
# overの物を解候補にリスト化する
over_list = [item for item in temp_point_list if item[1] >= G]
# print(over_list)
# 全bitが立っている最大値はターゲットを超えているため必ず値を持つ
over_combo = min(over_list, key = lambda x:x[0])
# print(over_combo)
# underのものを解候補にリスト化する
under_combo = [item for item in temp_point_list if item[1] < G]
# print(over_combo)
# print(under_combo)
temp_res_list = []
is_search = True
for temp_combo in under_combo:
temp_bit_list = temp_combo[2]
temp_res_point = temp_combo[1]
temp_res_num = temp_combo[0]
# print(temp_combo)
# print(temp_bit_list)
for j, item in reversed(list(enumerate(temp_bit_list))):
for _ in range(1, comp_bounas_list[j][0]):
# print(temp_res_point)
if item==0:
temp_res_point += (j+1)*100
temp_res_num += 1
if temp_res_point >= G:
temp_res_list.append([temp_res_num, temp_res_point])
break
# print(temp_res_list)
# きっかりコンプすれば必ずターゲットを超える場合、値を持たない場合がある。
# ダミーでres_candiに全bitの立った値を入れておく
if temp_res_list != []:
res_candi = min(temp_res_list, key=lambda x:x[0])
else:
res_candi = temp_point_list[-1]
if over_combo[0] <= res_candi[0]:
print((over_combo[0]))
else:
print((res_candi[0]))
|
p03290
|
def calcScore(d, g, scoreMap, index, score, solved):
minSolved = 0
for i in range(scoreMap[index][0] + 1):
scoreNow = score + 100 * (index + 1) * i
if i == scoreMap[index][0]:
scoreNow += scoreMap[index][1]
solvedNow = solved + i
if scoreNow >= g:
if minSolved == 0 or minSolved > solvedNow:
return solvedNow
else:
return minSolved
tmpSolved = 0
if index < d - 1:
tmpSolved = calcScore(d, g, scoreMap, index + 1, scoreNow, solvedNow)
if minSolved == 0 or (minSolved > tmpSolved and tmpSolved != 0):
minSolved = tmpSolved
return minSolved
d, g = list(map(int, input().split()))
scoreMap = [list(map(int, input().split())) for i in range(d)]
solved = calcScore(d, g, scoreMap, 0, 0, 0)
print(solved)
|
d, g = list(map(int, input().split()))
scoreMap = [list(map(int, input().split())) for i in range(d)]
minimum = 0
for i in range(2**d):
score = 0
solved = 0
for j in range(d):
if (i >> j) & 1 == 1:
score += scoreMap[j][0] * 100 * (j + 1) + scoreMap[j][1]
solved += scoreMap[j][0]
if score < g:
for k in range(d)[::-1]:
if (i >> k) & 1 == 0:
if (g - score > scoreMap[k][0] * 100 * (k + 1)):
score += scoreMap[k][0] * 100 * (k + 1) + scoreMap[k][1]
solved += scoreMap[k][0]
if score > g:
break
else:
solved += (g - score) // (100 * (k + 1))
if (g - score) % (100 * (k + 1)) != 0:
solved += 1
score = g
break
if minimum == 0 or solved < minimum:
minimum = solved
print(minimum)
|
p03290
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.