Problem:


Score : 700 points

Problem Statement

We have a rooted binary tree with N vertices, where the vertices are numbered 1 to N.
Vertex 1 is the root, and the parent of Vertex i (i \geq 2) is Vertex \left[ \frac{i}{2} \right].

Each vertex has one item in it. The item in Vertex i has a value of V_i and a weight of W_i.
Now, process the following query Q times:

Given are a vertex v of the tree and a positive integer L.
  Let us choose some (possibly none) of the items in v and the ancestors of v so that their total weight is at most L.
  Find the maximum possible total value of the chosen items.

Here, Vertex u is said to be an ancestor of Vertex v when u is an indirect parent of v, that is, there exists a sequence of vertices w_1,w_2,\ldots,w_k (k\geq 2) where w_1=v, w_k=u, and w_{i+1} is the parent of w_i for each i.

Constraints

All values in input are integers.

1 \leq N < 2^{18}

1 \leq Q \leq 10^5

1 \leq V_i \leq 10^5

1 \leq W_i \leq 10^5

For the values v and L given in each query, 1 \leq v \leq N and 1 \leq L \leq 10^5.

Input

Let v_i and L_i be the values v and L given in the i-th query.
Then, Input is given from Standard Input in the following format:

N
V_1 W_1
:
V_N W_N
Q
v_1 L_1
:
v_Q L_Q

Output

For each integer i from 1 through Q,
the i-th line should contain the response to the i-th query.

Sample Input 1

3
1 2
2 3
3 4
3
1 1
2 5
3 5

Sample Output 1

0
3
3

In the first query, we are given only one choice: the item with (V, W)=(1,2). Since L = 1, we cannot actually choose it, so our response should be 0.

In the second query, we are given two choices: the items with (V, W)=(1,2) and (V, W)=(2,3). Since L = 5, we can choose both of them, so our response should be 3.

Sample Input 2

15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227

Sample Output 2

256
255
250
247
255
259
223
253



Sample input:
3
1 2
2 3
3 4
3
1 1
2 5
3 5


Sample output:
0
3
3

Submission status: Time Limit Exceeded

Solution code:
def main():
  import sys
  input = sys.stdin.readline
  import math
  from collections import deque
  N = int(input())
  VW = [list(map(int,input().split())) for _ in range(N)]
  Q = int(input())
  vL = [list(map(int,input().split())) for _ in range(Q)]
  M = 0
  for v,L in vL:
    M = max(L,M)
    
  D = int(math.log2(N)) + 1
  K = D//2
  multiplier = 2**K
  M_plu = M+1
  Ddp = [[0] * (M_plu) for _ in range(multiplier)]
  
  mi_mul = multiplier-1
  tmp = VW[:mi_mul]
  for i,(V,W) in enumerate(tmp,1):
    x = i//2
    for j in range(M_plu):
      if W<=j:
        Ddp[i][j] = max(Ddp[x][j-W] + V, Ddp[x][j])
      else:
        Ddp[i][j] = Ddp[x][j]
        
  for v,L in vL:
    if v<=mi_mul:
      print(Ddp[v][L])
      continue
      
    else:
      y = v
      l = deque([])
      x = int(math.log2(v)) + 1
      x_K = x-K
      for i in range(x_K):
        vw = VW[y-1]
        if vw[1]<=L:
          l.append(vw)
        y //= 2
      ans = 0
      length = len(l)
      
      for i in range(2**length):
        z = [0,0]
        for j in range(length):
          if i>>j&1:
            vw = l[j]
            z[0] += vw[0]
            z[1] += vw[1]

          if z[1]>L:
            break
        if z[1]>L:
          continue
        else:
          ans = max(ans, Ddp[y][L-z[1]] + z[0])

    print(ans)
main()

Submission status: Time Limit Exceeded

Solution code:
import sys


def main():
    input = sys.stdin.readline

    n = int(input())

    L_MAX = 10**5
    D_TH = 9
    V_MAX = (1 << D_TH) - 1
    dp = [[0] * (L_MAX + 1) for _ in range(V_MAX + 1)]
    items = []

    for i in range(n):
        val, w = map(int, input().split())
        if i < V_MAX:
            i1 = i + 1
            i0 = (i - 1) // 2 + 1
            for j in range(L_MAX + 1):
                if j < w:
                    dp[i1][j] = dp[i0][j]
                else:
                    dp[i1][j] = max(dp[i0][j], dp[i0][j - w] + val)
        else:
            items.append((val, w))

    q = int(input())
    for _ in range(q):
        v, l = map(int, input().split())
        v -= 1

        if v < V_MAX:
            ans = dp[v + 1][l]
        else:
            vv = []
            ww = []
            while v >= V_MAX:
                vv.append(items[v - V_MAX][0])
                ww.append(items[v - V_MAX][1])
                v = (v - 1) // 2

            ans = dp[v + 1][l]
            m = len(vv)
            v_sub = [0] * (1 << m)
            w_sub = [0] * (1 << m)
            for bit in range(1, 1 << m):
                bit_min = bit & (-bit)
                x = bit_min.bit_length() - 1

                s_w = w_sub[bit - bit_min] + ww[x]
                w_sub[bit] = s_w
                if s_w <= l:
                    s_val = v_sub[bit - bit_min] + vv[x]
                    v_sub[bit] = s_val
                    ans = max(ans, dp[v + 1][l - s_w] + s_val)
            # print(items_sub)
            # print(w_sub)
            # print(v_sub)
            # print([dp[v + 1][l - w_sub[i]] + v_sub[i] for i in range(1 << m)])

        print(ans)


if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
import sys


def main():
    input = sys.stdin.readline

    n = int(input())

    L_MAX = 10**5
    D_TH = 10
    V_MAX = (1 << D_TH) + 200 - 1
    dp = [[0] * (L_MAX + 1) for _ in range(V_MAX + 1)]
    items = []

    for i in range(n):
        val, w = map(int, input().split())
        if i < V_MAX:
            i1 = i + 1
            i0 = (i - 1) // 2 + 1
            for j in range(L_MAX + 1):
                if j < w:
                    dp[i1][j] = dp[i0][j]
                else:
                    dp[i1][j] = max(dp[i0][j], dp[i0][j - w] + val)
        else:
            items.append((val, w))

    q = int(input())
    for _ in range(q):
        v, l = map(int, input().split())
        v -= 1

        if v < V_MAX:
            ans = dp[v + 1][l]
        else:
            vv = []
            ww = []
            while v >= V_MAX:
                vv.append(items[v - V_MAX][0])
                ww.append(items[v - V_MAX][1])
                v = (v - 1) // 2

            ans = dp[v + 1][l]
            m = len(vv)
            v_sub = [0] * (1 << m)
            w_sub = [0] * (1 << m)
            for bit in range(1, 1 << m):
                bit_min = bit & (-bit)
                x = bit_min.bit_length() - 1

                s_w = w_sub[bit - bit_min] + ww[x]
                w_sub[bit] = s_w
                if s_w <= l:
                    s_val = v_sub[bit - bit_min] + vv[x]
                    v_sub[bit] = s_val
                    ans = max(ans, dp[v + 1][l - s_w] + s_val)
            # print(items_sub)
            # print(w_sub)
            # print(v_sub)
            # print([dp[v + 1][l - w_sub[i]] + v_sub[i] for i in range(1 << m)])

        print(ans)


if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
import sys


def main():
    input = sys.stdin.readline

    n = int(input())

    L_MAX = 10**5
    D_TH = 10
    V_MAX = (1 << D_TH) - 1
    dp = [[0] * (L_MAX + 1) for _ in range(V_MAX + 1)]
    items = []

    for i in range(n):
        val, w = map(int, input().split())
        items.append((val, w))
        if i < V_MAX:
            i1 = i + 1
            i0 = (i - 1) // 2 + 1
            for j in range(L_MAX + 1):
                if j < w:
                    dp[i1][j] = dp[i0][j]
                else:
                    dp[i1][j] = max(dp[i0][j], dp[i0][j - w] + val)

    q = int(input())
    for _ in range(q):
        v, l = map(int, input().split())
        v -= 1

        if v < V_MAX:
            ans = dp[v + 1][l]
        else:
            vv = []
            ww = []
            while v >= V_MAX:
                vv.append(items[v][0])
                ww.append(items[v][1])
                v = (v - 1) // 2

            ans = dp[v + 1][l]
            m = len(vv)
            v_sub = [0] * (1 << m)
            w_sub = [0] * (1 << m)
            for bit in range(1, 1 << m):
                bit_min = bit & (-bit)
                x = bit_min.bit_length() - 1

                s_w = w_sub[bit - bit_min] + ww[x]
                w_sub[bit] = s_w
                if s_w <= l:
                    s_val = v_sub[bit - bit_min] + vv[x]
                    v_sub[bit] = s_val
                    ans = max(ans, dp[v + 1][l - s_w] + s_val)
            # print(items_sub)
            # print(w_sub)
            # print(v_sub)
            # print([dp[v + 1][l - w_sub[i]] + v_sub[i] for i in range(1 << m)])

        print(ans)


if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
import sys


def main():
    input = sys.stdin.readline

    n = int(input())

    L_MAX = 10**5
    D_TH = 10
    V_MAX = (1 << D_TH) - 1
    dp = [[0] * (L_MAX + 1) for _ in range(V_MAX + 1)]
    items = []

    for i in range(n):
        val, w = map(int, input().split())
        items.append((val, w))
        if i < V_MAX:
            i1 = i + 1
            i0 = (i - 1) // 2 + 1
            for j in range(L_MAX + 1):
                if j < w:
                    dp[i1][j] = dp[i0][j]
                else:
                    dp[i1][j] = max(dp[i0][j], dp[i0][j - w] + val)

    q = int(input())
    for _ in range(q):
        v, l = map(int, input().split())
        v -= 1

        if v < V_MAX:
            ans = dp[v + 1][l]
        else:
            items_sub = []
            while v >= V_MAX:
                items_sub.append(items[v])
                v = (v - 1) // 2

            ans = dp[v + 1][l]
            m = len(items_sub)
            v_sub = [0] * (1 << m)
            w_sub = [0] * (1 << m)
            for bit in range(1, 1 << m):
                bit_min = bit & (-bit)
                x = bit_min.bit_length() - 1

                s_w = w_sub[bit - bit_min] + items_sub[x][1]
                w_sub[bit] = s_w
                if s_w <= l:
                    s_val = v_sub[bit - bit_min] + items_sub[x][0]
                    v_sub[bit] = s_val
                    ans = max(ans, dp[v + 1][l - s_w] + s_val)
            # print(items_sub)
            # print(w_sub)
            # print(v_sub)
            # print([dp[v + 1][l - w_sub[i]] + v_sub[i] for i in range(1 << m)])

        print(ans)


if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
N = int(readline())
data = list(map(int,read().split()))
 
V = (0, ) + tuple(data[:2*N:2])
W = (0, ) + tuple(data[1:2*N:2])
Q = data[2*N]
NODE = tuple(data[2*N+1::2])
L = tuple(data[2*N+2::2])
 
bound = 512
M = max(L)

dp = [[0] * (M+1) for i in range(bound)]
for i in range(1, bound):
  if i > N:
    break
  v, w = V[i], W[i]
  par = i//2
  for wi in range(M+1):
    if wi < w:
      dp[i][wi] = dp[par][wi]
    else:
      dp[i][wi] = max(dp[par][wi], dp[par][wi-w]+v)

def calc(node, l):
  value = 0
  res = [(0, 0)]
  while node >= bound:
    v, w = V[node], W[node]
    temp = [(vi+v, wi+w) for vi, wi in res if wi+w<=l]
    res += temp
    node //= 2
  for v, w in res:
    value = max(value, dp[node][l-w] + v)
  return value

ans = []
for node, l in zip(NODE, L):
  if node < bound:
    ans.append(dp[node][l])
  else:
    ans.append(calc(node, l))

print(*ans, sep='\n')

Submission status: Time Limit Exceeded

Solution code:
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

#n,k,*a = map(int,read().split())

n, = map(int,readline().split())
vw = [[0,0]]+[list(map(int,readline().split())) for _ in range(n)]

def merge(av,aw,bv,bw):
    la,lb = len(aw),len(bw)
    rv = [0]*(la+lb)
    rw = [0]*(la+lb)
    ia = ib = 0
    for i in range(la+lb):
        if ib==lb or (ia < la and aw[ia] < bw[ib]):
            rv[i] = av[ia]
            rw[i] = aw[ia]
            ia += 1
        else:
            rv[i] = bv[ib]
            rw[i] = bw[ib]
            ib += 1
    return rv,rw

A = 9
N = min(1<<A,n+1)
memov = [[] for _ in range(N)]
memow = [[] for _ in range(N)]

memov[0] = [0]
memow[0] = [0]

#from itertools import acumulate
for i in range(1,N):
    v,w = vw[i]
    m2v = [v+v1 for v1 in memov[i>>1]]
    m2w = [w+w1 for w1 in memow[i>>1]]
    memov[i],memow[i] = merge(memov[i>>1],memow[i>>1],m2v,m2w)

    #memov[i] = list(accumulate(memov[i],max))
    for j in range(1,len(memov[i])):
        memov[i][j] = max(memov[i][j-1],memov[i][j])
    
def solve(lstv,lstw,dv,dw,l):
    ans = 0
    idx = len(lstw)-1
    #print(lstv,lstw,dv,dw,l)
    for v,w in zip(dv,dw):
        while idx >= 0 and lstw[idx] + w > l:
            idx -= 1
        if idx >= 0 and v+lstv[idx] > ans:
            ans = v+lstv[idx]
    print(ans)        
 
 

q, = map(int,readline().split())
for _ in range(q):
    u,l = map(int,readline().split())

    dv = [0]
    dw = [0]
    while u >= N:
        v,w = vw[u]
        m2v = [v+v1 for v1 in dv]
        m2w = [w+w1 for w1 in dw]
        dv,dw = merge(dv,dw,m2v,m2w)
        u >>= 1
    
    #for j in range(1,len(dv)):
    #    dv[j] = max(dv[j-1],dv[j])
    
    solve(memov[u],memow[u],dv,dw,l)

#print(memov)
#print(memow)

Submission status: Time Limit Exceeded

Solution code:
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

#n,k,*a = map(int,read().split())

n, = map(int,readline().split())
vw = [[0,0]]+[list(map(int,readline().split())) for _ in range(n)]

def merge(av,aw,bv,bw):
    la,lb = len(aw),len(bw)
    rv = [0]*(la+lb)
    rw = [0]*(la+lb)
    ia = ib = 0
    for i in range(la+lb):
        if ib==lb or (ia < la and aw[ia] < bw[ib]):
            rv[i] = av[ia]
            rw[i] = aw[ia]
            ia += 1
        else:
            rv[i] = bv[ib]
            rw[i] = bw[ib]
            ib += 1
    return rv,rw

A = 2
N = min(1<<A,n+1)
memov = [[] for _ in range(N)]
memow = [[] for _ in range(N)]

memov[0] = [0]
memow[0] = [0]

#from itertools import acumulate
for i in range(1,N):
    v,w = vw[i]
    m2v = [v+v1 for v1 in memov[i>>1]]
    m2w = [w+w1 for w1 in memow[i>>1]]
    memov[i],memow[i] = merge(memov[i>>1],memow[i>>1],m2v,m2w)

    #memov[i] = list(accumulate(memov[i],max))
    for j in range(1,len(memov[i])):
        memov[i][j] = max(memov[i][j-1],memov[i][j])
    
def solve(lstv,lstw,dv,dw,l):
    ans = 0
    idx = len(lstw)-1
    #print(lstv,lstw,dv,dw,l)
    for v,w in zip(dv,dw):
        while idx >= 0 and lstw[idx] + w > l:
            idx -= 1
        if idx >= 0 and v+lstv[idx] > ans:
            ans = v+lstv[idx]
    print(ans)        
 
 

q, = map(int,readline().split())
for _ in range(q):
    u,l = map(int,readline().split())

    dv = [0]
    dw = [0]
    while u >= N:
        v,w = vw[u]
        m2v = [v+v1 for v1 in dv]
        m2w = [w+w1 for w1 in dw]
        dv,dw = merge(dv,dw,m2v,m2w)
        u >>= 1
    
    #for j in range(1,len(dv)):
    #    dv[j] = max(dv[j-1],dv[j])
    
    solve(memov[u],memow[u],dv,dw,l)

#print(memov)
#print(memow)

Submission status: Time Limit Exceeded

Solution code:
import sys
input = sys.stdin.readline

N = int(input())
bound = 512
VW = [(0, 0)] + [tuple(map(int, input().split())) for i in range(N)]
Q = int(input())
nodeL = [tuple(map(int, input().split())) for i in range(Q)]
M = max(nl[1] for nl in nodeL)

dp = [[0] * (M+1) for i in range(bound)]
for i in range(1, bound):
  if i > N:
    break
  v, w = VW[i]
  par = i//2
  for wi in range(M+1):
    if wi < w:
      dp[i][wi] = dp[par][wi]
    else:
      dp[i][wi] = max(dp[par][wi], dp[par][wi-w]+v)

def calc(node, L):
  value = 0
  res = [(0, 0)]
  while node >= bound:
    v, w = VW[node]
    temp = [(vi+v, wi+w) for vi, wi in res if wi+w<=L]
    res += temp
    node //= 2
  for v, w in res:
    value = max(value, dp[node][L-w] + v)
  return value

ans = []
for node, L in nodeL:
  if node < bound:
    ans.append(dp[node][L])
  else:
    ans.append(calc(node, L))

print(*ans, sep='\n')

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
M = 10**5
bound = 512
VW = [(0, 0)] + [tuple(map(int, input().split())) for i in range(N)]

dp = [[0] * (M+1) for i in range(bound)]
for i in range(1, bound):
  if i > N:
    break
  v, w = VW[i]
  par = i//2
  for wi in range(M+1):
    if wi < w:
      dp[i][wi] = dp[par][wi]
    else:
      dp[i][wi] = max(dp[par][wi], dp[par][wi-w]+v)

def calc(node, L):
  value = 0
  res = [(0, 0)]
  while node >= bound:
    v, w = VW[node]
    temp = [(vi+v, wi+w) for vi, wi in res if wi+w<=L]
    res += temp
    node //= 2
  for v, w in res:
    value = max(value, dp[node][L-w] + v)
  return value


Q = int(input())
ans = []
for q in range(Q):
  node, L = map(int, input().split())
  if node < bound:
    ans.append(dp[node][L])
  else:
    ans.append(calc(node, L))

print(*ans, sep='\n')

Submission status: Time Limit Exceeded

Solution code:
import sys,bisect
input=sys.stdin.readline

N=int(input())
vw=[(-1,-1)]
for i in range(N):
    vw.append(tuple(map(int,input().split())))

dp=[[0 for i in range(100001)] for i in range(2**9)]
for i in range(vw[1][1],100001):
    dp[1][i]=vw[1][0]
MAX=min(2**9,N+1)
for i in range(2,MAX):
    v,w=vw[i]
    for j in range(100001):
        dp[i][j]=max(dp[i//2][j],(dp[i//2][j-w]+v)*(j>=w))

temp=[[0,0] for i in range(2**9)]

def solve(v,L):
    t=[]
    while v>=2**9:
        t.append(vw[v])
        v//=2
    n=len(t)
    for i in range(1,2**n):
        m=i.bit_length()
        temp[i][0]=temp[i-2**(m-1)][0]+t[m-1][0]
        temp[i][1]=temp[i-2**(m-1)][1]+t[m-1][1]
    ans=0
    for i in range(2**n):
        if L>=temp[i][1]:
            ans=max(ans,temp[i][0]+dp[v][L-temp[i][1]])
    return ans

def main():
    for i in range(int(input())):
        v,L=map(int,input().split())
        print(solve(v,L))

if __name__=="__main__":
    main()

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
M = 10**5
bound = 1024
VW = [(0, 0)] + [tuple(map(int, input().split())) for i in range(N)]

dp = [[0] * (M+1) for i in range(bound)]
for i in range(1, bound):
  if i > N:
    break
  v, w = VW[i]
  par = i//2
  for wi in range(M+1):
    if wi < w:
      dp[i][wi] = dp[par][wi]
    else:
      dp[i][wi] = max(dp[par][wi], dp[par][wi-w]+v)

def enum(node):
  res = []
  while node >= bound:
    res.append(node)
    node //= 2
  return res, node

def calc(node, L):
  nodes, par = enum(node)
  cands = [(0, 0)]
  res = 0
  for node in nodes:
    v, w = VW[node]
    temp = [(vi+v, wi+w) for vi, wi in cands]
    cands += temp
  for v, w in cands:
    if w <= L:
      res = max(res, dp[par][L-w] + v)
  return res

Q = int(input())
ans = []
for q in range(Q):
  node, L = map(int, input().split())
  if node < bound:
    ans.append(dp[node][L])
  else:
    ans.append(calc(node, L))

print(*ans, sep='\n')

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
M = 10**5
VW = [(0, 0)] + [tuple(map(int, input().split())) for i in range(N)]

dp = [[0] * (M+1) for i in range(512)]
for i in range(1, 512):
  if i > N:
    break
  v, w = VW[i]
  par = i//2
  for wi in range(M+1):
    if wi < w:
      dp[i][wi] = dp[par][wi]
    else:
      dp[i][wi] = max(dp[par][wi], dp[par][wi-w]+v)

def enum(node):
  res = []
  while node > 511:
    res.append(node)
    node //= 2
  return res, node

def calc(node, L):
  nodes, par = enum(node)
  cands = [(0, 0)]
  res = 0
  for node in nodes:
    v, w = VW[node]
    temp = [(vi+v, wi+w) for vi, wi in cands]
    cands += temp
  for v, w in cands:
    if w <= L:
      res = max(res, dp[par][L-w] + v)
  return res

Q = int(input())
ans = []
for q in range(Q):
  node, L = map(int, input().split())
  if node <= 511:
    ans.append(dp[node][L])
  else:
    ans.append(calc(node, L))

print(*ans, sep='\n')

Submission status: Time Limit Exceeded

Solution code:
import sys
from collections import deque
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
inf = 10**6


def main():
    N = int(input())
    VW = [(inf, inf)] + [list(map(int, input().split())) for _ in range(N)]
    Q = int(input())
    query = tuple(tuple(map(int, input().split())) for _ in range(Q))
    D = N.bit_length()

    for n, L in query:
        memo1 = deque([(0, 0)])  # w,v
        memo2 = deque([(0, 0)])  # w,v
        while n > 0:
            vi, wi = VW[n]
            if n <= 2048:
                res = deque([(-1, -1)])
                m1 = deque([(wi + w, vi + v) for w, v in memo1])
                while m1 and memo1:
                    if m1[0][0] >= memo1[0][0]:
                        w, v = memo1.popleft()
                    else:
                        w, v = m1.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                while m1:
                    w, v = m1.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                while memo1:
                    w, v = memo1.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                res.popleft()
                memo1 = res
            else:
                res = deque([(-1, -1)])
                m2 = deque([(wi + w, vi + v) for w, v in memo2])
                while m2 and memo2:
                    if m2[0][0] >= memo2[0][0]:
                        w, v = memo2.popleft()
                    else:
                        w, v = m2.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                while m2:
                    w, v = m2.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                while memo2:
                    w, v = memo2.popleft()
                    if res[-1][0] < w:
                        res.append((w, v))
                    elif res[-1][1] < v:
                        res.pop()
                        res.append((w, v))
                res.popleft()
                memo2 = res
            n //= 2

        ans = 0
        memo2.reverse()
        j = len(memo2) - 1
        for w, v in memo1:
            if w > L:
                break
            while j >= 0 and w + memo2[j][0] > L:
                j -= 1
            if j < 0:
                break
            ans = max(ans, v + memo2[j][1])
        print(ans)


if __name__ == "__main__":
    main()

Submission status: Time Limit Exceeded

Solution code:
import sys
from collections import deque
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
inf = 10**6


N = int(input())
VW = [(inf, inf)] + [list(map(int, input().split())) for _ in range(N)]
Q = int(input())
query = tuple(tuple(map(int, input().split())) for _ in range(Q))
D = N.bit_length()

for n, L in query:
    memo1 = deque([(0, 0)])  # w,v
    memo2 = deque([(0, 0)])  # w,v
    while n > 0:
        vi, wi = VW[n]
        if n <= 1024:
            res = deque([(-1, -1)])
            m1 = deque([(wi + w, vi + v) for w, v in memo1])
            while m1 and memo1:
                if m1[0][0] >= memo1[0][0]:
                    w, v = memo1.popleft()
                else:
                    w, v = m1.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))

            while m1:
                w, v = m1.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))
            while memo1:
                w, v = memo1.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))
            res.popleft()
            memo1 = res
        else:
            res = deque([(-1, -1)])
            m2 = deque([(wi + w, vi + v) for w, v in memo2])
            while m2 and memo2:
                if m2[0][0] >= memo2[0][0]:
                    w, v = memo2.popleft()
                else:
                    w, v = m2.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))
            while m2:
                w, v = m2.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))
            while memo2:
                w, v = memo2.popleft()
                if res[-1][0] < w:
                    res.append((w, v))
                elif res[-1][1] < v:
                    res.pop()
                    res.append((w, v))
            res.popleft()
            memo2 = res
        n //= 2

    ans = 0
    memo2.reverse()
    j = len(memo2) - 1
    for w, v in memo1:
        if w > L:
            break
        while j >= 0 and w + memo2[j][0] > L:
            j -= 1
        if j < 0:
            break
        ans = max(ans, v + memo2[j][1])
    print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys,bisect
input=sys.stdin.readline

N=int(input())
vw=[(-1,-1)]
for i in range(N):
    vw.append(tuple(map(int,input().split())))

dp=[[0 for i in range(100001)] for i in range(2**9)]
for i in range(vw[1][1],100001):
    dp[1][i]=vw[1][0]
MAX=min(2**9,N+1)
for i in range(2,MAX):
    v,w=vw[i]
    for j in range(100001):
        dp[i][j]=max(dp[i//2][j],(dp[i//2][j-w]+v)*(j>=w))

for i in range(int(input())):
    v,L=map(int,input().split())
    if 2**9>v:
        print(dp[v][L])
    else:
        t=[]
        while v>=2**9:
            t.append(vw[v])
            v//=2
        n=len(t)
        ans=0
        for i in range(2**n):
            V=sum(t[j][0] for j in range(n) if i>>j &1==1)
            W=sum(t[j][1] for j in range(n) if i>>j &1==1)
            if L>=W:
                ans=max(ans,V+dp[v][L-W])
        print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys,bisect
input=sys.stdin.readline

N=int(input())
vw=[(-1,-1)]
for i in range(N):
    vw.append(tuple(map(int,input().split())))

dp=[[0 for i in range(100001)] for i in range(2**9)]
for i in range(vw[1][1],100001):
    dp[1][i]=vw[1][0]
MAX=min(2**9,N+1)
for i in range(2,MAX):
    v,w=vw[i]
    for j in range(100001):
        dp[i][j]=max(dp[i//2][j],(dp[i//2][j-w]+v)*(j>=w))

temp=[[0,0] for i in range(2**9)]
for i in range(int(input())):
    v,L=map(int,input().split())
    if 2**9>v:
        print(dp[v][L])
    else:
        t=[]
        while v>=2**9:
            t.append(vw[v])
            v//=2
        n=len(t)
        temp[0][0]=0
        temp[0][1]=0
        for i in range(1,2**n):
            m=i.bit_length()
            temp[i][0]=temp[i-2**(m-1)][0]+t[m-1][0]
            temp[i][1]=temp[i-2**(m-1)][1]+t[m-1][1]
        ans=0
        for i in range(2**n):
            if L>=temp[i][1]:
                ans=max(ans,temp[i][0]+dp[v][L-temp[i][1]])
        print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys,bisect
input=sys.stdin.readline

N=int(input())
vw=[(-1,-1)]
for i in range(N):
    vw.append(tuple(map(int,input().split())))

dp=[[0 for i in range(100001)] for i in range(2**10)]
for i in range(vw[1][1],100001):
    dp[1][i]=vw[1][0]
MAX=min(2**10,N+1)
for i in range(2,MAX):
    v,w=vw[i]
    for j in range(w):
        dp[i][j]=dp[i//2][j]
    for j in range(w,100001):
        dp[i][j]=max(dp[i//2][j],dp[i//2][j-w]+v)

temp=[[0,0] for i in range(2**10)]
for i in range(int(input())):
    v,L=map(int,input().split())
    if 2**10>v:
        print(dp[v][L])
    else:
        t=[]
        while v>=2**10:
            t.append(vw[v])
            v//=2
        n=len(t)
        temp[0][0]=0
        temp[0][0]=0
        for i in range(1,2**n):
            m=i.bit_length()
            temp[i][0]=temp[i-2**(m-1)][0]+t[m-1][0]
            temp[i][1]=temp[i-2**(m-1)][1]+t[m-1][1]
        ans=0
        for i in range(2**n):
            if L>=temp[i][1]:
                ans=max(ans,temp[i][0]+dp[v][L-temp[i][1]])
        print(ans)

Submission status: Time Limit Exceeded

Solution code:
def main():
  import sys
  input = sys.stdin.readline
  import math
  from collections import deque
  N = int(input())
  VW = [list(map(int,input().split())) for _ in range(N)]
  Q = int(input())
  vL = [list(map(int,input().split())) for _ in range(Q)]
  M = 0
  for q in range(Q):
    x = vL[q][1]
    if x>M:
      M = x

  D = int(math.log2(N)) + 1
  K = D//2
  Ddp = [[0] * (M+1) for _ in range(2**K)]
  for i in range(1,2**K):
    V,W = VW[i-1]
    for j in range(M+1):
      if W<=j:
        Ddp[i][j] = max(Ddp[i//2][j-W] + V, Ddp[i//2][j])
      else:
        Ddp[i][j] = Ddp[i//2][j]


  for q in range(Q):
    v,L = vL[q]
    if v<=2**K - 1:
      print(Ddp[v][L])
      continue
    else:
      y = v
      l = deque([])
      x = int(math.log2(v)) + 1
      for i in range(x - K):
        vw = VW[y-1]
        if vw[1]<=L:
          l.append(vw)
        y //= 2
      ans = 0
      length = len(l)
      for i in range(2**length):
        z = [0,0]
        for j in range(length):
          if i>>j&1:
            vw = l[j]
            z[0] += vw[0]
            z[1] += vw[1]

          if z[1]>L:
            break
        if z[1]>L:
          continue
        else:
          ans = max(ans, Ddp[y][L-z[1]] + z[0])

    print(ans)
    
main()

Submission status: Time Limit Exceeded

Solution code:
def main():
  import sys
  input = sys.stdin.readline
  N = int(input())
  VW = [list(map(int,input().split())) for _ in range(N)]
  Q = int(input())
  vL = [list(map(int,input().split())) for _ in range(Q)]
  M = 0
  import math
  from collections import deque
  for q in range(Q):
    x = vL[q][1]
    if x>M:
      M = x

  D = int(math.log2(N)) + 1
  K = D//2
  Ddp = [[0] * (M+1) for _ in range(2**K)]
  for i in range(1,2**K):
    V,W = VW[i-1]
    for j in range(M+1):
      if W<=j:
        Ddp[i][j] = max(Ddp[i//2][j-W] + V, Ddp[i//2][j])
      else:
        Ddp[i][j] = Ddp[i//2][j]


  for q in range(Q):
    v,L = vL[q]
    if v<=2**K - 1:
      print(Ddp[v][L])
      continue
    else:
      y = v
      l = deque([])
      x = int(math.log2(v)) + 1
      for i in range(x - K):
        vw = VW[y-1]
        if vw[1]<=L:
          l.append(vw)
        y //= 2
      ans = 0
      length = len(l)
      for i in range(2**length):
        z = [0,0]
        for j in range(length):
          if i>>j&1:
            vw = l[j]
            z[0] += vw[0]
            z[1] += vw[1]

          if z[1]>L:
            break
        if z[1]>L:
          continue
        else:
          ans = max(ans, Ddp[y][L-z[1]] + z[0])

    print(ans)
    
main()