Problem:


Score : 300 points

Problem Statement

A programming competition site AtCode provides algorithmic problems.
Each problem is allocated a score based on its difficulty.
Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points.
These p_1 + … + p_D problems are all of the problems available on AtCode.

A user of AtCode has a value called total score.
The total score of a user is the sum of the following two elements:

Base score: the sum of the scores of all problems solved by the user.

Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 ≤ i ≤ D).

Takahashi, who is the new user of AtCode, has not solved any problem.
His objective is to have a total score of G or more points.
At least how many problems does he need to solve for this objective?

Constraints

1 ≤ D ≤ 10

1 ≤ p_i ≤ 100

100 ≤ c_i ≤ 10^6

100 ≤ G

All values in input are integers.

c_i and G are all multiples of 100.

It is possible to have a total score of G or more points.

Input

Input is given from Standard Input in the following format:

D G
p_1 c_1
:
p_D c_D

Output

Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).

Sample Input 1

2 700
3 500
5 800

Sample Output 1

3

In this case, there are three problems each with 100 points and five problems each with 200 points. The perfect bonus for solving all the 100-point problems is 500 points, and the perfect bonus for solving all the 200-point problems is 800 points. Takahashi's objective is to have a total score of 700 points or more.

One way to achieve this objective is to solve four 200-point problems and earn a base score of 800 points. However, if we solve three 100-point problems, we can earn the perfect bonus of 500 points in addition to the base score of 300 points, for a total score of 800 points, and we can achieve the objective with fewer problems.

Sample Input 2

2 2000
3 500
5 800

Sample Output 2

7

This case is similar to Sample Input 1, but the Takahashi's objective this time is 2000 points or more. In this case, we inevitably need to solve all five 200-point problems, and by solving two 100-point problems additionally we have the total score of 2000 points.

Sample Input 3

2 400
3 500
5 800

Sample Output 3

2

This case is again similar to Sample Input 1, but the Takahashi's objective this time is 400 points or more. In this case, we only need to solve two 200-point problems to achieve the objective.

Sample Input 4

5 25000
20 1000
40 1000
50 1000
30 1000
1 1000

Sample Output 4

66

There is only one 500-point problem, but the perfect bonus can be earned even in such a case. 



Sample input:
2 700
3 500
5 800


Sample output:
3

Submission status: Runtime Error

Solution code:
D,G=map(int,input().split())
import math
ans=10**9
prob=[]
for i in range(D):
  p,c=map(int,input().split())
  prob.append((p,c))
for i in range(2**D):
  i=format(i-1,'b').rjust(D,'0')
  alll=[]
  notall=[]
  for j in range(D):
    if i[j]=='1':
      alll.append(j)
    else:
      notall.append(j)
  if notall!=[]:
    maxnotall=notall[-1]  
  point=0
  tans=0
  for i in alll:
    point+=100*(i+1)*prob[i][0]+prob[i][1]
    tans+=prob[i][0]
  if point>=G:
    ans=min(tans,ans)
  if point<G:
    if 100*(maxnotall+1)*(prob[maxnotall][0]-1)>=G-point:
      tans+=math.ceil((G-point)/(100*(maxnotall+1)))
      ans=min(tans,ans)
    else:
      ans=ans

if ans==10**9:
  ans=0
  for i in range(N):
    ans+=prob[i][0]
print(ans)

Submission status: Runtime Error

Solution code:
from itertools import combinations
N, M = map(int, input().split())
link = [[0 for i in range(N)] for j in range(N)]
for m in range(M):
    x, y = map(int, input().split())
    link[x-1][y-1] = 1
    link[y-1][x-1] = 1

for i in range(N,1,-1): # N, N-1, N-2, ... 2
    for comb in combinations(range(N),i):
        for c in combinations(comb, 2): # 議員の集合に対して考えられるペアを列挙
            if (link[c[0]][c[1]] == 0): # 一つでも知り合いでない組があればNG
                break
        else: # 派閥が作れた段階でプログラムを終了
            print (i)
            exit()
print (1)

Submission status: Runtime Error

Solution code:
import sys,math,collections,itertools,copy
input = sys.stdin.readline

D,G=list(map(int,input().split()))
score = []
maxScore = []
cos_per = []
for d in range(D):
    p,c=map(int,input().split())
    tmp = [(d+1)*100]*p
    tmp[-1]+=c
    score.append(tmp)
    maxScore.append(sum(tmp))
    #cos_per.append([d+1,sum(tmp)/p])
    cos_per.append([d+1,d+1])
#-最大いくつの問題セットを必要とするか-#
maxScore.sort()
tmp = 0
for idx,mS in enumerate(maxScore):
    tmp += mS
    if tmp >= G:
        max_num = idx+1
        break
#-最小でいくつの問題セットを必要とするか-#
tmp = 0
j=0
for i in range(len(maxScore)-1,-1,-1):
    j+=1
    tmp += maxScore[i]
    if tmp >= G:
        min_num = j
        break
#-最小-2個はスコアが高いものを入れてよし-#
#cos_per.sort(key = lambda x:-x[1])
#choice = set(range(1,D+1))
#choiceList = []
#for i in range(0,min_num-3):
 #   choiceList+=score[cos_per[i][0]-1]
 #   choice.discard(cos_per[i][0])
 #   max_num -=1
 
#-足し上げる-#

ans = float('inf')
for ch in itertools.permutations(choice,max_num):
    times = 0
    total = 0
    flag = 0
    for ci in ch:
        for sc in score[ci-1]:
            total += sc
            times += 1
            if total >= G:
                ans = min(ans,times)
                falg = 1
                break
    if flag ==1:
        break
print(ans)

Submission status: Runtime Error

Solution code:
D,G = map(int, input().split())
xy = [map(int, input().split()) for _ in range(D)]
x, y = [list(i) for i in zip(*xy)]

ans = []

for i in range(2**D):
  tot = 0
  cnt = 0
  rem = set(range(1, D+1))
  for j in range(D):
    if (i>>j) & 1:
      tot += x[0]*(i+1)*100+y[0]
      cnt += x[0]
      rem.discard(i+1)
  
  if tot < G:
    A = max(rem)
    n = min(x[A-1], (G-tot)//(A*100))
    cnt += n
    tot += A*n*100
    
  if tot >= G:
    ans.append(cnt)

print(min(ans))

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
pc = [list(map(int, input().split())) for i in range(D)]

ans = float("inf")

for bit in range(1 << D):
    count = 0
    sum = 0
    rest = list(range(1, D+1))

    for i in range(D):
        if bit & (1 << i):
            sum += 100 * i * pc[i][0] + pc[i][1]
            count += pc[i][0]
            rest.remove(i+1)
    if sum < G:
        max_num = max(rest)
        n = min(pc[max_num - 1][0], (G - sum) // (max_num * 100))
        count += n
        sum += n*max_num * 100
    if sum >= G:
        ans = min(ans, count)

print(ans)

Submission status: Runtime Error

Solution code:
#abc104c All Green
#全てとかない問いは一種類以下になるので、各問いに対し解く/解かないを決める

def dfs(i, sum, count, rest):
    global ans
    if i == d:
        if sum < g:
            rest_max = max(rest)
            n = min(l[rest_max-1][0], -(-(g-sum)//(rest_max*100)))
            count += n
            sum += n * rest_max * 100
        if sum >= g:
            ans = min(ans, count)
    else :
        dfs(i+1, sum, count, rest) #二分岐のうち解かない選択
        dfs(i+1, sum + l[i][0]*(i+1)*100, count + l[i][0], rest - {i+1}) #解く選択

d, g = map(int, input().split())
l = [list((map(int, input().split()))) for _ in range(d)]
ans = float("inf")
dfs(0, 0, 0, set(range(1, d+1)))
print(ans)

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
PC = [0]+[list(map(int,input().split())) for _ in range(D)]

def dfs(d, g):
    if(d == 0):
        return 1e9

    c = min(g//(100*d), PC[d][0])
    s = 100*d*c
    if c == PC[d][0]:
        s += PC[d][1]
    if s<g:
        c += f(d-1, g-s)
    return min(c, f(d-1,g))

print(dfs(D, G))

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
PC = [0]+[list(map(int,input().split())) for _ in range(D)]

def dfs(d, g):
    # if(d == 0):
    #     return 1e9

    c = min(g//(100*d), PC[d][0])
    s = 100*d*c
    if c == PC[d][0]:
        s += PC[d][1]
    if s<g:
        c += f(d-1, g-s)
    return min(c, f(d-1,g))

print(dfs(D, G))

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
PC = [0]+[list(map(int,input().split())) for _ in range(D)]
print(1e9)

def dfs(d, g):
    if(d == 0):
        return 1e9

    c = min(g//(100*d), PC[d][0])
    s = 100*d*c
    if c == PC[d][0]:
        s += PC[d][1]
    if s<g:
        c += f(d-1, g-s)
    return min(c, f(d-1,g))

print(dfs(D, G))

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
PC = [0]+[list(map(int,input().split())) for _ in range(D)]
print(1e9)

def dfs(d, g):
    # if(d == 0):
    #     return 1e9

    c = min(g//(100*d), PC[d][0])
    s = 100*d*c
    if c == PC[d][0]:
        s += PC[d][1]
    if s<g:
        c += f(d-1, g-s)
    return min(c, f(d-1,g))

print(dfs(D, G))

Submission status: Runtime Error

Solution code:
D, G = map(int, input().split())
P = [list(map(int, input().split())) for d in range(D)]
ans = 1000

for i in range(1 << D):
    s = 0
    n = 0
    for j in range(D):
        if i >> j & 1 == 1:
            s += 100 * (j + 1) * P[j][0] + P[j][1]
            n += P[j][0]
    for j in range(D - 1, 0, -1):
        if i >> j & 1 == 0:
            r = (G - s) // 100 // (j +1)
            if r > P[j][0]:
                n = 1000
            else:
                n += max(r, 0)
            break
    ans = min(ans, n)

print(ans)

D, G = map(int, input().split())
P = [list(map(int, input().split())) for d in range(D)]
ans = 1000

for i in range(1 << D):
    s = 0
    n = 0
    for j in range(D):
        if i >> j & 1 == 1:
            s += 100 * (j + 1) * P[j][0] + P[j][1]
            n += P[j][0]
    for j in range(D - 1, 0, -1):
        if i >> j & 1 == 0:
            r = ((G - s) // 100 + j) // (j + 1)
            if r > P[j][0]:
                n = 1000
            else:
                n += max(r, 0)
            break
    ans = min(ans, n)

print(ans)

Submission status: Runtime Error

Solution code:
# abc104_c.py
# https://atcoder.jp/contests/abc104/tasks/abc104_c

# C - All Green /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点 : 300点

# 問題文
# プログラミングコンペティションサイト AtCode は、アルゴリズムの問題集を提供しています。 
# それぞれの問題には、難易度に応じて点数が付けられています。 
# 現在、1以上 D 以下のそれぞれの整数 i に対して、100i 点を付けられた問題が pi 問存在します。 
# これらの p1+…+pD問が AtCode に収録された問題のすべてです。
# AtCode のユーザーは 総合スコア と呼ばれる値を持ちます。 ユーザーの総合スコアは、以下の 2つの要素の和です。

#     基本スコア: ユーザーが解いた問題すべての配点の合計です。
#     コンプリートボーナス: 100i点を付けられた pi 問の問題すべてを解いたユーザーは、基本スコアと別にコンプリートボーナス ci 点を獲得します 
#     (1≤i≤D)。

# AtCode の新たなユーザーとなった高橋くんは、まだ問題を 1問も解いていません。 
# 彼の目標は、総合スコアを G点以上にすることです。 このためには、少なくとも何問の問題を解く必要があるでしょうか？

# 制約
#     1≤D≤10
#     1≤pi≤100
#     100≤ci≤106
#     100≤G
#     入力中のすべての値は整数である。
#     ci,Gはすべて 100の倍数である。
#     総合スコアを G点以上にすることは可能である。

# 入力
# 入力は以下の形式で標準入力から与えられる。

# D G
# p1 c1
# :
# pD cD


# 出力
# 総合スコアを G点以上にするために解く必要のある最小の問題数を出力せよ。なお、この目標は必ず達成可能である（制約を参照のこと）。

# 入力例 1
# 2 700
# 3 500
# 5 800

# 出力例 1
# 3

# この場合、AtCode には 100点を付けられた問題が 3 問、200 点を付けられた問題が 5 問あります。
# 100 点の 3 問をすべて解いた際のコンプリートボーナスは 500 点、200 点の 5 問をすべて解いた際のコンプリートボーナスは 800 点です。
# 高橋くんの目標は総合スコアを 700点以上にすることです。

# 目標を達成する方法の一つは、200点問題を 4 問解いて 800 点の基本スコアを得ることです。
# しかし、100 点問題を 3 問すべて解くと、基本スコア 300 点に加えてコンプリートボーナスの 500 点が与えられて総合スコアが 800点となり、より少ない問題数で目標を達成することができます。

# 入力例 2
# 2 2000
# 3 500
# 5 800

# 出力例 2
# 7

# 入力例 1 と似たケースですが、今回の高橋くんの目標は 2000点以上です。
# この場合、200 点の 5 問は必ずすべて解かなければならず、さらに 100 点問題を 2 問解くことで総合スコアが 2000点となります。

# 入力例 3
# 2 400
# 3 500
# 5 800

# 出力例 3
# 2

# ふたたび入力例 1 と似たケースですが、今回の高橋くんの目標は 400点以上です。
# この場合、200 点問題を 2問解くだけで目標を達成できます。

# 入力例 4
# 5 25000
# 20 1000
# 40 1000
# 50 1000
# 30 1000
# 1 1000

# 出力例 4
# 66

# 500点の問題が 1 問しか存在しませんが、このような場合でもその問題を解くことでコンプリートボーナスが与えられます。


def calculation(lines):
    D, G = list(map(int, lines[0].split()))
    bits = get_bits(D)
    bits_num = list()
    pcs = list()
    for i in range(D):
        p, c = list(map(int, lines[i+1].split()))
        pcs.append((p, c))
    # どのパターンがOKか探す
    for bit in bits:
        c_score = 0
        c_num = 0
        rem_i = -1
        for i in range(D):
            if bit[i] == '1':
                p, c = pcs[i]
                # コンプリートスコアを加算
                c_score += (i+1)*100*p + c
                # その時の問題数を加算
                c_num += p
            else:
                # 解かなかった問題を保持
                rem_i = i
        # すでに届いていればそれが(このbitでえられる)解
        if c_score > G:
            bit_num = c_num
        # そうでなければ、不足分を加算
        else:
            # 1問当たりの点数
            ten = (rem_i+1)*100
            bit_num = c_num - ((-G+c_score)//ten)
        bits_num.append(bit_num)

    return [min(bits_num)]


# 2進数で(0...0)～(1...1)というn文字を2^n個返す
def get_bits(n):
    ret = list()
    for i in range(2**n, 2**(n+1)):
        ret.append(format(i, 'b')[1:])
    return ret


# 引数を取得
def get_input_lines():
    line = input()
    D, G = list(map(int, line.split()))
    lines = list()
    lines.append(line)
    for _ in range(D):
        lines.append(input())
    return lines


# テストデータ
def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['2 700', '3 500', '5 800']
        lines_export = [3]
    if pattern == 2:
        lines_input = ['2 2000', '3 500', '5 800']
        lines_export = [7]
    if pattern == 3:
        lines_input = ['2 400', '3 500', '5 800']
        lines_export = [2]
    if pattern == 4:
        lines_input = ['5 25000', '20 1000', '40 1000', '50 1000', '30 1000', '1 1000']
        lines_export = [66]
    return lines_input, lines_export


# 動作モード判別
def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode


# 主処理
def main():
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines()
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    # if mode > 0:
    #     print(f'lines_input=[{lines_input}]')
    #     print(f'lines_export=[{lines_export}]')
    #     print(f'lines_result=[{lines_result}]')
    #     if lines_result == lines_export:
    #         print('OK')
    #     else:
    #         print('NG')


# 起動処理
if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
# abc104_c.py
# https://atcoder.jp/contests/abc104/tasks/abc104_c

# C - All Green /
# 実行時間制限: 2 sec / メモリ制限: 1024 MB
# 配点 : 300点

# 問題文
# プログラミングコンペティションサイト AtCode は、アルゴリズムの問題集を提供しています。 
# それぞれの問題には、難易度に応じて点数が付けられています。 
# 現在、1以上 D 以下のそれぞれの整数 i に対して、100i 点を付けられた問題が pi 問存在します。 
# これらの p1+…+pD問が AtCode に収録された問題のすべてです。
# AtCode のユーザーは 総合スコア と呼ばれる値を持ちます。 ユーザーの総合スコアは、以下の 2つの要素の和です。

#     基本スコア: ユーザーが解いた問題すべての配点の合計です。
#     コンプリートボーナス: 100i点を付けられた pi 問の問題すべてを解いたユーザーは、基本スコアと別にコンプリートボーナス ci 点を獲得します 
#     (1≤i≤D)。

# AtCode の新たなユーザーとなった高橋くんは、まだ問題を 1問も解いていません。 
# 彼の目標は、総合スコアを G点以上にすることです。 このためには、少なくとも何問の問題を解く必要があるでしょうか？

# 制約
#     1≤D≤10
#     1≤pi≤100
#     100≤ci≤106
#     100≤G
#     入力中のすべての値は整数である。
#     ci,Gはすべて 100の倍数である。
#     総合スコアを G点以上にすることは可能である。

# 入力
# 入力は以下の形式で標準入力から与えられる。

# D G
# p1 c1
# :
# pD cD


# 出力
# 総合スコアを G点以上にするために解く必要のある最小の問題数を出力せよ。なお、この目標は必ず達成可能である（制約を参照のこと）。

# 入力例 1
# 2 700
# 3 500
# 5 800

# 出力例 1
# 3

# この場合、AtCode には 100点を付けられた問題が 3 問、200 点を付けられた問題が 5 問あります。
# 100 点の 3 問をすべて解いた際のコンプリートボーナスは 500 点、200 点の 5 問をすべて解いた際のコンプリートボーナスは 800 点です。
# 高橋くんの目標は総合スコアを 700点以上にすることです。

# 目標を達成する方法の一つは、200点問題を 4 問解いて 800 点の基本スコアを得ることです。
# しかし、100 点問題を 3 問すべて解くと、基本スコア 300 点に加えてコンプリートボーナスの 500 点が与えられて総合スコアが 800点となり、より少ない問題数で目標を達成することができます。

# 入力例 2
# 2 2000
# 3 500
# 5 800

# 出力例 2
# 7

# 入力例 1 と似たケースですが、今回の高橋くんの目標は 2000点以上です。
# この場合、200 点の 5 問は必ずすべて解かなければならず、さらに 100 点問題を 2 問解くことで総合スコアが 2000点となります。

# 入力例 3
# 2 400
# 3 500
# 5 800

# 出力例 3
# 2

# ふたたび入力例 1 と似たケースですが、今回の高橋くんの目標は 400点以上です。
# この場合、200 点問題を 2問解くだけで目標を達成できます。

# 入力例 4
# 5 25000
# 20 1000
# 40 1000
# 50 1000
# 30 1000
# 1 1000

# 出力例 4
# 66

# 500点の問題が 1 問しか存在しませんが、このような場合でもその問題を解くことでコンプリートボーナスが与えられます。


def calculation(lines):
    D, G = list(map(int, lines[0].split()))
    bits = get_bits(D)
    bits_num = list()
    pcs = list()
    for i in range(D):
        p, c = list(map(int, lines[i+1].split()))
        pcs.append((p, c))
    # どのパターンがOKか探す
    for bit in bits:
        c_score = 0
        c_num = 0
        rem_i = -1
        for i in range(D):
            if bit[i] == '1':
                p, c = pcs[i]
                # コンプリートスコアを加算
                c_score += (i+1)*100*p + c
                # その時の問題数を加算
                c_num += p
            else:
                # 解かなかった問題を保持
                rem_i = i
        # すでに届いていればそれが(このbitでえられる)解
        if c_score > G:
            bit_num = c_num
        # そうでなければ、不足分を加算
        else:
            # 1問当たりの点数
            ten = (rem_i+1)*100
            bit_num = c_num - ((-G+c_score)//ten)
        bits_num.append(bit_num)

    return [min(bits_num)]


# 2進数で(0...0)～(1...1)というn文字を2^n個返す
def get_bits(n):
    ret = list()
    for i in range(2**n, 2**(n+1)):
        ret.append(format(i, 'b')[1:])
    return ret


# 引数を取得
def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines


# テストデータ
def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['2 700', '3 500', '5 800']
        lines_export = [3]
    if pattern == 2:
        lines_input = ['2 2000', '3 500', '5 800']
        lines_export = [7]
    if pattern == 3:
        lines_input = ['2 400', '3 500', '5 800']
        lines_export = [2]
    if pattern == 4:
        lines_input = ['5 25000', '20 1000', '40 1000', '50 1000', '30 1000', '1 1000']
        lines_export = [66]
    return lines_input, lines_export


# 動作モード判別
def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode


# 主処理
def main():
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    # if mode > 0:
    #     print(f'lines_input=[{lines_input}]')
    #     print(f'lines_export=[{lines_export}]')
    #     print(f'lines_result=[{lines_result}]')
    #     if lines_result == lines_export:
    #         print('OK')
    #     else:
    #         print('NG')


# 起動処理
if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
#abc104c all green 
d, g = map(int, input().split())
pc = [list(map(int, input().split())) for _ in range(d)]
all_sum = []
for i in range(2**d):
    s = 0
    a = 0
    rest = []
    for j in range(d):
        if i & (2**j):#&はANDであり，0 or 1だけで判別
            s =s+ pc[j][0]*100*(j+1) + pc[j][1]
            a =a+ pc[j][0]  
        else :
            rest.append(i) 
    if s >= g :
        all_sum.append(a)
    else :
        l = max(rest)
        diff = g - s
        for k in range(pc[l][0]):
            if j*(l+1)*100 >= diff:
                all_sum.append(a+k)
print(min(all_sum))

Submission status: Runtime Error

Solution code:
d, g = map(int, input().split())
pc = [list(map(int, input().split())) for _ in range(d)]
all_sum = []
for i in range(2**d):
    s = 0
    a = 0
    rest = []
    for j in range(d):
        if i & (2**j):#&はANDであり，0 or 1だけで判別
            s =s+ pc[j][0]*100*(j+1) + pc[j][1]
            a =a+ pc[j][0]   
    if s >= g :
        all_sum.append(a)
    else :
        l = max(rest)
        diff = g - s
        for k in range(pc[l][0]):
            if j*(l+1)*100 >= diff:
                all_sum.append(a+k)
print(min(all_sum))

Submission status: Runtime Error

Solution code:
import numpy as np

D, G, *pc = map(int, open(0).read().split())
pc = list(zip(*[iter(pc)]*2))
p, c = np.array([]), np.array([])
for (x,y) in pc:
    p = np.append(p, x)
    c = np.append(c, y)
    
import numpy as np
import math

base_points = np.array([i*100 for i in range(1, D+1)])

ans = []

for i in range(2**D):
    bit_flag = np.array(list(map(int, format(i, '0%db' %D))))
    
    points = sum(bit_flag * (c + p*base_points))
    solved_num = sum(bit_flag * p)
    
    if points >= G:
        ans.append(solved_num)

    else:
        achieved = False
        remained = G - points
        remained_problems = sorted((bit_flag==False) * np.array(range(1, D+1)), reverse=True)
        i = 0

        while not achieved:
            highest_p = remained_problems[i]
            if remained <= 0:
                achieved = True
            elif math.ceil(remained / (highest_p * 100)) <= p[highest_p - 1]:
                solved_num += math.ceil(remained / (highest_p * 100))
                remained -= (math.ceil(remained / (highest_p * 100)) * highest_p * 100)
            else:
                solved_num += p[highest_p - 1]
                remained -= (highest_p * 100 * p[highest_p - 1] + c[highest_p - 1])
                i += 1

        ans.append(solved_num)
        
print(int(min(ans)))

Submission status: Runtime Error

Solution code:
D, G, *pc = map(int, open(0).read().split())
pc = list(zip(*[iter(pc)]*2))

# 全完一つで達成できるケース

total_points = []
for i in range(D):
    total_points.append(pc[i][0] * (i+1) * 100 + pc[i][1])
    
ans_list = [i[0] for i, x in zip(pc, total_points) if x >= G]

# 完答ボーナスを含め、最も効率の良い問題から解くケース
efficient_order = sorted(list(zip([x/y for x,(y,z) in list(zip(total_points, pc))], range(1, D+1))), reverse = True)

achieved = False
remained = G
highest_p = D

ans_other = 0

for _, i in efficient_order:
        if remained <= 0:
            break
        elif math.ceil(remained / (i * 100)) <= pc[i - 1][0]:
            ans_other += math.ceil(remained / (i * 100))
            remained -= (math.ceil(remained / (i * 100)) * i * 100)
        else:
            ans_other += pc[i - 1][0]
            remained -= (i * 100 * pc[i - 1][0] + pc[i - 1][1])

ans_list.append(ans_other)

print(min(ans_list))

Submission status: Runtime Error

Solution code:
D, G, *pc = map(int, open(0).read().split())
pc = list(zip(*[iter(pc)]*2))

total_points = []
for i in range(D):
    total_points.append(pc[i][0] * (i+1) * 100 + pc[i][1])
    
ans_list = [i[0] for i, x in zip(pc, total_points) if x >= G]

import math

achieved = False
remained = G
highest_p = D

ans_other = 0

while not achieved:
    if math.ceil(remained / (highest_p * 100)) <= pc[highest_p - 1][0]:
        ans_other += math.ceil(remained / (highest_p * 100))
        achieved = True
    else:
        ans_other += pc[highest_p - 1][0]
        remained -= (highest_p * 100 * pc[highest_p - 1][0] + pc[highest_p - 1][1])
        highest_p -= 1
        
ans_list.append(ans_other)

print(min(ans_list))

Submission status: Runtime Error

Solution code:
D,G = map(int,input().split())
ab = []
for _ in range(D):
    p, c = (int(x) for x in input().split())
    ab.append([p,c])

ans = 10000000

pick_num = []

for i in range(D):
    pick_num.append(i)

for i in range(0,D+1):
    for v in itertools.combinations(pick_num, i):      
        tmp_point = 0
        tmp_count = 0
        for j in v:
            tmp_point += ab[j][0]*(j+1)*100+ab[j][1]
            tmp_count += ab[j][0]
        if tmp_point < G:
            nokori = G-tmp_point
            for k in range(D-1, -1,-1):
                if k not in v:
                    if nokori%(100*(k+1)) == 0:
                        if nokori//(100*(k+1)) < ab[k][0]:
                            tmp_count += nokori//(100*(k+1))
                            tmp_point += nokori
                    else:
                        if nokori//(100*(k+1))+1 < ab[k][0]:
                            tmp_count += nokori//(100*(k+1))+1
                            tmp_point += nokori
                    break
        if G <= tmp_point:
            ans = min(ans, tmp_count)
print(ans)

Submission status: Runtime Error

Solution code:
D, G = [int(n) for n in input().split()]

score_table = []
for i in range(1, D+1):
    p, c = [int(n) for n in input().split()]
    score_table.append([i*100, p, c])

min_count = sum([l[1] for l in score_table])
#print(min_count)

for bit in range(1<<D):
    score = 0
    count = 0

    for i in range(D):
        if bit & (1<<i):
            score += score_table[i][0] * score_table[i][1] + score_table[i][2]
            count += score_table[i][1]
    
    if score >= G:
        min_count = min(min_count, count)
    else:
        additional = []
        for j in range(D):
            if not bit & (1<<j):
                additional.append(score_table[j])
        
        additional_ = sorted(additional, key=lambda x:x[0], reverse=True)
        #print(additional_)
        
        for i in additional_:
            if i[1] > 1:
                add_score = i
                break

        #add_score = additional_[0]

        for k in range(add_score[1]-1):
            score += add_score[0]
            count += 1
            if score >= G:
                min_count = min(min_count, count)

print(min_count)

Submission status: Runtime Error

Solution code:
D, G = [int(n) for n in input().split()]

score_table = []
for i in range(1, D+1):
    p, c = [int(n) for n in input().split()]
    score_table.append([i*100, p, c])

min_count = sum([l[1] for l in score_table])
#print(min_count)

for bit in range(1<<D):
    score = 0
    count = 0

    for i in range(D):
        if bit & (1<<i):
            score += score_table[i][0] * score_table[i][1] + score_table[i][2]
            count += score_table[i][1]
    
    if score >= G:
        min_count = min(min_count, count)
    else:
        additional = []
        for j in range(D):
            if not bit & (1<<j):
                additional.append(score_table[j])
        
        additional_ = sorted(additional, key=lambda x:x[0], reverse=True)
        #print(additional_)
        
        for i in additional_:
            if i[1] > 1:
                add_score = i
                break
        
        for k in range(1, add_score[1]):
            score += add_score[0]
            count += 1
            if score >= G:
                min_count = min(min_count, count)

print(min_count)

Submission status: Runtime Error

Solution code:
D, G = [int(n) for n in input().split()]

score_table = []
for i in range(1, D+1):
    p, c = [int(n) for n in input().split()]
    score_table.append([i*100, p, c])

min_count = sum([l[1] for l in score_table])
#print(min_count)

for bit in range(1<<D):
    score = 0
    count = 0

    for i in range(D):
        if bit & (1<<i):
            score += score_table[i][0] * score_table[i][1] + score_table[i][2]
            count += score_table[i][1]
    
    if score >= G:
        min_count = min(min_count, count)
    else:
        additional = []
        for j in range(D):
            if not bit & (1<<j):
                additional.append(score_table[j])
        
        additional_ = sorted(additional, key=lambda x:x[0], reverse=True)
        #print(additional_)
        
        for i in additional_:
            if i[1] != 1:
                add_score = i
                break
        
        for k in range(1, add_score[1]):
            score += add_score[0]
            count += 1
            if score >= G:
                min_count = min(min_count, count)

print(min_count)

Submission status: Runtime Error

Solution code:
from itertools import product
n,k = map(int,input().split())
L = []
for i in range(n):
    a,b = map(int,input().split())
    L.append([0,a,b])
for i in range(n):
    L[i][0] = 100*(i+1)
#print(L)
li = [0,1]
re = []

def cer(v):
    for i in range(n-1,0,-1):
        if v[i] == 0:
            return i
            
for v in product(li,repeat = n):
    score = 0
    scorenomi = 0
    num = 0
    for i in range(n):
        score += (L[i][0]*L[i][1] + L[i][2])*v[i]
        scorenomi +=L[i][0]*L[i][1]*v[i]
        num +=L[i][1]*v[i]
    if score < k:
        j = 1
        score2 = 0
        while j <= L[cer(v)][1]:
            score2 = L[cer(v)][0]*j
            if score + score2 >=k:
                break
            j +=1
        #print(num,i,j,num + j,score,score2,score + score2,v)
    if score+ score2 >=k:
        print(num +j)
        exit()
    re.append([score,scorenomi,num,v])
re.sort()
for i in range(len(re)):
    if re[i][0] >=k:
        print(re[i][2])
        exit()

Submission status: Runtime Error

Solution code:
P=[]
C=[]
point=1001    #全問題数

D,G=map(int,input().split())
for i in range(D):
    p,c= map(int,input().split())
    P.append(p)
    C.append(c)

#とりあえず全部解くor解かないで目標スコアを超えるか超えないかを考える


for i in range(2**D) :
    score=0
    solve=0
    needproblem=0
    for j in range(D) :                  #全正解した大問をスコアに変換
        if (i>>j) & 1 :
            score+=P[j]*100*(j+1)+C[j]
            solve+=P[j]
    if score>=G :
        point=min(point,solve)

#ぎりぎりスコアが届いていない場合、1問も解かなかった問題の中で最も一題あたりの点が高い問題だけ解いてみる
#中途半端に大問を解ききるのが１種類以下でも目標に届く場合もあるという予想
    elif score<G :
        rest=G-score
        for j in range(D) :
            if (~i>>D-j) & 1 :
                needproblem=D-j+1
            sum=needproblem*100*(P[needproblem-1]-1)
            if rest>sum :            #1問も解かなかった問題の中で最も一題あたりの点が高い問題を解いても届かないのでやり直し
                rest-=sum
                solve+=P[needproblem-1]-1
            elif rest<=sum :
                resolve=solve+rest//(needproblem*100)
                point=min(point,resolve)
                continue

print(point)

Submission status: Runtime Error

Solution code:

D,G=map(int,input().split())
for i in range(D):
    p,c= map(int,input().split())
    P.append(p)
    C.append(c)

#とりあえず全部解くor解かないで目標スコアを超えるか超えないかを考える


for i in range(2**D) :
    score=0
    solve=0
    needproblem=0
    for j in range(D) :                  #全正解した大問をスコアに変換
        if (i>>j) & 1 :
            score+=P[j]*100*(j+1)+C[j]
            solve+=P[j]
    if score>=G :
        if D*100>solve :
            point=min(point,solve)
        continue

#ぎりぎりスコアが届いていない場合、1問も解かなかった問題の中で最も一題あたりの点が高い問題だけ解いてみる
#中途半端に大問を解ききるのが１種類以下でも目標に届く場合もあるという予想
    rest=G-score
    for j in range(D) :
        if (i>>j) & 1==0 :
            needproblem=j+1
            sum=needproblem*100*(P[needproblem-1]-1)
            if rest>sum :            #1問も解かなかった問題の中で最も一題あたりの点が高い問題を解いても届かないのでやり直し
                continue
            elif rest<=sum :
                resolve=solve+rest//(needproblem*100)
                point=min(point,resolve)

print(point)

Submission status: Runtime Error

Solution code:
P=[]
C=[]
point=1001    #全問題数

D,G=map(int,input().split())
for i in range(D):
    p,c= map(int,input().split())
    P.append(p)
    C.append(c)

#とりあえず全部解くor解かないで目標スコアを超えるか超えないかを考える


for i in range(2**D) :
    score=0
    solve=0
    needproblem=0
    for j in range(D) :                  #全正解した大問をスコアに変換
        if (i>>j) & 1 :
            score+=P[j]*100*(j+1)+C[j]
            solve+=P[j]
    if score>=G :
        if D*100>solve :
            point=min(point,solve)
         continue

#ぎりぎりスコアが届いていない場合、1問も解かなかった問題の中で最も一題あたりの点が高い問題だけ解いてみる
#中途半端に大問を解ききるのが１種類以下でも目標に届く場合もあるという予想
    rest=G-score
    for j in range(D) :
        if (i>>j) & 1==0 :
            needproblem=j+1
            sum=needproblem*100*(P[needproblem-1]-1)
            if rest>sum :            #1問も解かなかった問題の中で最も一題あたりの点が高い問題を解いても届かないのでやり直し
                continue
            elif rest<=sum :
                resolve=solve+rest//(needproblem*100)
                point=min(point,resolve)

print(point)