Buggy python submission (verdict: Time Limit Exceeded):
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) + [i] for i in range(D)]
# pc.sort(key=lambda x: -((x[2] + 1) * x[0] + x[1]))

# depth-first-like search
G_tab = [(x[2] + 1) * x[0] + x[1] for x in pc]
cnt_tab = [x[0] for x in pc]
G_stack = G_tab[0]
cnt_stack = cnt_tab[0]
order = [0]

mincnt = D_MAX * P_MAX
while True:
    ## deepth increament (continue)
    if G_stack < G:
        # append lowest item (always break?)
        for i in range(D):
            if i not in order: break
        order.append(i)
        G_stack += G_tab[i]
        cnt_stack += cnt_tab[i]
        continue
    ## skip check
    idx_tmp = order[-1]
    G_tmp = G_stack - G_tab[idx_tmp]
    cnt_tmp = cnt_stack - cnt_tab[idx_tmp]
    if cnt_tmp < mincnt:
        ## evaluate cnt_last
        x = pc[order[-1]]
        cnt_last = x[0]
        for i in range(x[0]):
            cnt_last -= 1
            G_last = (x[2] + 1) * cnt_last
            # print("##", cnt_last, G_tmp + G_last, G)
            if G_tmp + G_last < G: break
        cnt_last += 1
        ## update mincnt
        # print("#", order, cnt_tmp, cnt_last, G - G_tmp, "/", mincnt)
        if cnt_tmp + cnt_last < mincnt: mincnt = cnt_tmp + cnt_last
    ## next node
    order_last = order[-1] + 1
    while True:
        if order_last > D - 1:
            idx_tmp = order[-1]
            G_stack -= G_tab[idx_tmp]
            cnt_stack -= cnt_tab[idx_tmp]
            order.pop()
            if len(order) < 1: break # end
            order_last = order[-1] + 1
            continue
        elif order_last in order:
            order_last = order_last + 1
            continue
        else:
            idx_tmp = order[-1]
            G_stack += (G_tab[order_last] - G_tab[idx_tmp])
            cnt_stack += (cnt_tab[order_last] - cnt_tab[idx_tmp])
            order[-1] = order_last
            break
    ## escape
    if len(order) < 1: break # end

print(mincnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Time Limit Exceeded):
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) + [i] for i in range(D)]
pc.sort(key=lambda x: -((x[2] + 1) * x[0] + x[1]))

# depth-first-like search
G_tab = [(x[2] + 1) * x[0] + x[1] for x in pc]
cnt_tab = [x[0] for x in pc]
G_stack = [G_tab[0]]
cnt_stack = [cnt_tab[0]]
order = [0]

mincnt = D_MAX * P_MAX
while True:
    ## deepth increament (continue)
    if sum(G_stack) < G:
        # append lowest item (always break?)
        for i in range(D):
            if i not in order: break
        order.append(i)
        G_stack.append(G_tab[i])
        cnt_stack.append(cnt_tab[i])
        continue
    ## skip check
    G_tmp = sum(G_stack[:-1])
    cnt_tmp = sum(cnt_stack[:-1])
    if cnt_tmp < mincnt:
        ## evaluate cnt_last
        idx = order[-1]
        x = pc[idx]
        cnt_last = x[0]
        for i in range(x[0]):
            cnt_last -= 1
            G_last = (x[2] + 1) * cnt_last
            # print("##", cnt_last, G_tmp + G_last, G)
            if G_tmp + G_last < G: break
        cnt_last += 1
        ## update mincnt
        # print("#", order, cnt_tmp, cnt_last, G - G_tmp, "/", mincnt)
        if cnt_tmp + cnt_last < mincnt: mincnt = cnt_tmp + cnt_last
    ## next node
    order_last = order[-1] + 1
    while True:
        if order_last > D - 1:
            G_stack.pop()
            cnt_stack.pop()
            order.pop()
            if len(order) < 1: break # end
            order_last = order[-1] + 1
            continue
        elif order_last in order:
            order_last = order_last + 1
            continue
        else:
            order[-1] = order_last
            G_stack[-1] = G_tab[order_last]
            cnt_stack[-1] = cnt_tab[order_last]
            break
    ## escape
    if len(order) < 1: break # end

print(mincnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Time Limit Exceeded):
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

# depth-first-like search
G_tab = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_tab = [x[0] for x in pc]
G_stack = [G_tab[0]]
cnt_stack = [cnt_tab[0]]
order = [0]

mincnt = D_MAX * P_MAX
while True:
    ## deepth increament (continue)
    if sum(G_stack) < G:
        # append lowest item (always break?)
        for i in range(D):
            if i not in order: break
        order.append(i)
        G_stack.append(G_tab[i])
        cnt_stack.append(cnt_tab[i])
        continue
    ## escape
    G_tmp = sum(G_stack[:-1])
    cnt_tmp = sum(cnt_stack[:-1])
    if cnt_tmp < mincnt:
        ## evaluate cnt_last
        idx = order[-1]
        x = pc[idx]
        cnt_last = x[0]
        for i in range(x[0]):
            cnt_last -= 1
            G_last = (idx + 1) * cnt_last
            # print("##", cnt_last, G_tmp + G_last, G)
            if G_tmp + G_last < G: break
        cnt_last += 1
        ## update mincnt
        # print("#", order, cnt_tmp, cnt_last, G - G_tmp, "/", mincnt)
        if cnt_tmp + cnt_last < mincnt: mincnt = cnt_tmp + cnt_last
    ## next node
    order_last = order[-1] + 1
    while True:
        if order_last > D - 1:
            G_stack.pop()
            cnt_stack.pop()
            order.pop()
            if len(order) < 1: break # end
            order_last = order[-1] + 1
            continue
        elif order_last in order:
            order_last = order_last + 1
            continue
        else:
            order[-1] = order_last
            G_stack[-1] = G_tab[order_last]
            cnt_stack[-1] = cnt_tab[order_last]
            break
    ## escape
    if len(order) < 1: break # end

print(mincnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Runtime Error):
# encoding: utf-8

P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]

def mycounter(item, G):
    Gtmp = (item[1] + 1) * item[2] + item[3]
    p_th = item[2]
    for i in range(item[2]):
        if Gtmp < G: break
        else:
            p_th -= 1
            Gtmp = (item[1] + 1) * p_th
    return p_th + 1

D, G = num_and_pnt(input().split())

# [flag, index, pi, ci]
pc = [[1, i] + num_and_pnt(input().split()) for i in range(D)]

cnt = 0
while True:
    # last point

    state = -1
    p_tmp = P_MAX
    for item in filter(lambda x: x[0] > 0, pc):
        Gtmp = (item[1] + 1) * item[2] + item[3]
        if G <= Gtmp:
            p = mycounter(item, G)
            if p < p_tmp:
                state = item[1]
                p_tmp = p
    # escape
    if state > -1:
        cnt += p_tmp
        # print("#", (state + 1) * 100, p_tmp)
        break
    # completed point
    item = max(list(filter(lambda x: x[0] > 0, pc)), key=lambda x: x[1] + x[3] / x[2])
    G -= (item[1] + 1) * item[2] + item[3]
    cnt += item[2]
    pc[item[1]][0] = 0
    # print("#", (item[1] + 1) * 100, item[2], G)
    
print(cnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Runtime Error):
# encoding: utf-8

P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]

def mycounter(item, G):
    Gtmp = (item[1] + 1) * item[2] + item[3]
    p_th = item[2]
    for i in range(item[2]):
        if Gtmp < G: break
        else:
            p_th -= 1
            Gtmp = (item[1] + 1) * p_th
    return p_th + 1

D, G = num_and_pnt(input().split())

# [flag, index, pi, ci]
pc = [[1, i] + num_and_pnt(input().split()) for i in range(D)]

cnt = 0
while True:
    # last point
    # print(G * 100, cnt, pc)
    state = -1
    p_tmp = P_MAX
    for item in filter(lambda x: x[0] > 0, pc):
        Gtmp = (item[1] + 1) * item[2] + item[3]
        if G <= Gtmp:
            p = mycounter(item, G)
            if p < p_tmp:
                # print(G * 100, (item[1] + 1) * 100, p)
                state = item[1]
                p_tmp = p
    # escape
    if state > -1:
        cnt += p_tmp
        break
    # completed point
    # print(pc)
    item = max(flist(ilter(lambda x: x[0] > 0, pc), key=lambda x: x[1] + x[3] / x[2]))
    G -= (item[1] + 1) * item[2] + item[3]
    cnt += item[2]
    pc[item[1]][0] = 0
    
print(cnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Runtime Error):
# encoding: utf-8

P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]

def mycounter(item, G):
    Gtmp = (item[1] + 1) * item[2] + item[3]
    p_th = item[2]
    for i in range(item[2]):
        if Gtmp < G: break
        else:
            p_th -= 1
            Gtmp = (item[1] + 1) * p_th
    return p_th + 1

D, G = num_and_pnt(input().split())

# [flag, index, pi, ci]
pc = [[1, i] + num_and_pnt(input().split()) for i in range(D)]

cnt = 0
while True:
    # last point
    # print(G * 100, cnt, pc)
    state = -1
    p_tmp = P_MAX
    for item in filter(lambda x: x[0] > 0, pc):
        Gtmp = (item[1] + 1) * item[2] + item[3]
        if G <= Gtmp:
            p = mycounter(item, G)
            if p < p_tmp:
                # print(G * 100, (item[1] + 1) * 100, p)
                state = item[1]
                p_tmp = p
    # escape
    if state > -1:
        cnt += p_tmp
        break
    # completed point
    # print(pc)
    item = max(filter(lambda x: x[0] > 0, pc), key=lambda x: x[1] + x[3] / x[2])
    G -= (item[1] + 1) * item[2] + item[3]
    cnt += item[2]
    pc[item[1]][0] = 0
    
print(cnt)
    

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)

Buggy python submission (verdict: Runtime Error):
# encoding: utf-8

P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]

def mycounter(item, G):
    Gtmp = (item[1] + 1) * (item[2] - 1)
    p = item[2]
    for i in range(p):
        if Gtmp < G: break
        else:
            Gtmp -= (item[1] + 1)
            p -= 1
    return p

D, G = num_and_pnt(input().split())

# [flag, index, pi, ci]
pc = [[1, i] + num_and_pnt(input().split()) for i in range(D)]

cnt = 0
while True:
    # print(pc)
    # last point
    state = -1
    p_tmp = P_MAX
    for item in filter(lambda x: x[0] > 0, pc):
        Gtmp = (item[1] + 1) * item[2] + item[3]
        if G <= Gtmp:
            p = mycounter(item, G)
            if p < p_tmp:
                state = item[1]
                p_tmp = p
    # escape
    if state > -1:
        cnt += p_tmp
        break
    # completed point
    item = max(filter(lambda x: x[0] > 0, pc), key=lambda x: x[1] + x[3] / x[2])
    G -= (item[1] + 1) * item[2] + item[3]
    cnt += item[2]
    pc[item[1]][0] = 0
    
print(cnt)

Fixed submission:
# encoding: utf-8
D_MAX = 10
P_MAX = 100

num_and_pnt = lambda x: [int(x[0]), int(x[1]) // 100]
D, G = num_and_pnt(input().split())
# [pi, ci]
pc = [num_and_pnt(input().split()) for i in range(D)]

G_list = [(i + 1) * x[0] + x[1] for i, x in enumerate(pc)]
cnt_list = [x[0] for i, x in enumerate(pc)]
idx = [map(int, format(i, "b")) for i in range(2 ** D)]

# i, G_comp, cnt_comp
table = [ (i, sum([((i // (2 ** j)) % 2) * G_list[j] for j in range(D)]), sum([((i // (2 ** j)) % 2) * cnt_list[j] for j in range(D)])) for i in range(2 ** D)] # very long
# print(table)
mincnt = D_MAX * P_MAX
for i, (G_last, cnt_last) in enumerate(zip(G_list, cnt_list)):
    for j, G_comp, cnt_comp in filter(lambda x: (((x[0] // (2 ** i)) % 2 == 0) and (x[1] <= G < x[1] + G_last) and (x[2] < mincnt)), table):
        # print(i, (G_last, cnt_last), j, G_comp, cnt_comp)
        cnt_last_tmp = min((-((G_comp - G) // (i + 1)), cnt_last))
        if cnt_comp + cnt_last_tmp < mincnt: mincnt = cnt_comp + cnt_last_tmp

print(mincnt)