class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # 设置两个指针
        left = 0
        right = len(nums)
        # 取值区间左闭右开
        # 循环条件就是左指针未超过右指针
        while left < right:# (不取等——因为右边是开)
            middle = (left + right) // 2   # 二分查找怎么确定中间值是直接除以二还是要加一
            # 这里不用加一 整除是向下取整的（奇数刚刚好，偶数偏小）
            if target < nums[middle]: # 用target和中间值作比较
                right = middle #调整右指针,能取等是因为本身右指针就取不到
            elif target > nums[middle]:
                left = middle + 1 #判断条件是大于，因此要调整为加一
            else:  #表示取到了
                return middle
        return -1 #必须放到循环外面知道循环结束都没找到再返回-1

class Solution:
    def lastStoneWeight(self, stones: List[int]) -> int:
        while len(stones) > 1:
            stones.sort()
            y = stones.pop()
            x = stones.pop()
            if x != y:
                stones.append(y-x)
        return stones[0] if stones else 0

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        if (target + sum(nums)) % 2 != 0:
            return 0
        if abs(target) > sum(nums):
            return 0
        bagweight = (target + sum(nums)) // 2
        dp = [0] * (bagweight + 1)
        dp[0] = 1
        for i in range(len(nums)):
            for j in range(bagweight, nums[i] - 1, -1):
                dp[j] += dp[j - nums[i]]
        return dp[bagweight]

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for str in strs:
            zero_num = str.count('0')
            one_num = str.count('1')
            for i in range(m, zero_num - 1, -1):
                for j in range(n, one_num - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i - zero_num][j - one_num] + 1)
        return dp[m][n]

n,bagweight = map(int,input().split())
weights = list(map(int,input().split()))
values = list(map(int,input().split()))
dp = [0]*(bagweight+1)
dp[0] = 0
for i in range(n):
    for j in range(bagweight,weights[i]-1,-1):
        dp[j] = max(dp[j],dp[j-weights[i]]+values[i])
print(dp[bagweight])

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if sum(nums)%2 != 0:
            return False
        target = sum(nums)//2
        dp = [0]*(target+1)
        dp[0] = 0
        for i in range(len(nums)):
            for j in range(target,nums[i]-1,-1):
                dp[j] = max(dp[j],dp[j-nums[i]]+nums[i])
        return dp[target] == target

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[0]*n for _ in range(m)]
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 1
        for i in range(1,m):
            for j in range(1,n):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
        return dp[m-1][n-1]

class Solution:
    def integerBreak(self, n: int) -> int:
        dp = [0]*(n+1)
        dp[2] = 1
        for i in range(3,n+1):
            for j in range(1,i//2+1):
                dp[i] = max(dp[i],max(j*(i-j),j*dp[i-j]))
        return dp[n]

class Solution:
    def numTrees(self, n: int) -> int:
        dp = [0]*(n+1)
        dp[0] = 1
        dp[1] = 1
        for i in range(2,n+1):
            for j in range(1,i+1):
                dp[i] += dp[j-1]*dp[i-j]
        return dp[n]

class Solution:
    def fib(self, n: int) -> int:
        dp = [0,1]
        if n == 0:
            return dp[0]
        if n == 1:
            return dp[1]
        else:
            return self.fib(n-2) + self.fib(n-1) 

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        if len(intervals) <= 1 :
            return intervals
        result = []
        intervals.sort(key = lambda x:x[0])
        result.append(intervals[0])
        for i in range(1,len(intervals)):
            if intervals[i][0] <= result[-1][1]:
                result[-1][1] = max(result[-1][1],intervals[i][1])
            else :
                result.append(intervals[i])
        return result

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        strn = str(n)
        flag = len(strn)
        for i in range(len(strn)-1,0,-1): #因为后续用i-1和i比较，不包含第一个来防止越界访问
            if strn[i-1] > strn[i]:
                flag = i
                strn = strn[0:i-1]+str(int(strn[i-1])-1)+strn[i:]
        for i in range(flag,len(strn)):
            strn = strn[:i] + "9" + strn[i+1:]
        return int(strn)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:

    # 0：未覆盖 1：有摄像头 2：有覆盖
    def minCameraCover(self, root: Optional[TreeNode]) -> int:
        self.result = 0
        if self.dfs(root,self.result) == 0:
            self.result += 1
        return self.result
    def dfs(self,cur,result):
        if cur == None:
            return 2
        left = self.dfs(cur.left,self.result)
        right = self.dfs(cur.right,self.result)
        if left == 2 and right == 2:
           return 0
        if left == 0 or right == 0 :
            self.result += 1 
            return 1
        if left == 1 or right == 1 :
            return 2 

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        if not points:
            return 0
        result = 1
        points.sort(key =lambda x:x[0])
        for i in range(1,len(points)):
            if points[i][0] > points[i-1][1]:
                result += 1
            else:
                points[i][1] = min(points[i-1][1],points[i][1])
        return result

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0
        result = 1
        intervals.sort(key = lambda x:x[0])
        for i in range(1,len(intervals)):
            if intervals[i][0] >= intervals[i-1][1]:
                result += 1
            else:
                intervals[i][1] = min(intervals[i][1],intervals[i-1][1])
        return len(intervals) - result

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        has = {}
        for i in range(len(s)):
            has[s[i]] = i
        result = []
        end = 0
        start = 0
        for i,c in enumerate(s):
            end = max(end,has[c])
            if i == end:
                result.append(end-start+1)
                start = i+1
        return result

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
        total = 0
        cur = 0
        start = 0
        for i in range(len(gas)):
            dle = gas[i] - cost[i]
            total += dle
            cur += dle
            if cur < 0:
                start = i + 1
                cur = 0
        if total < 0:
            return -1
        return start

class Solution:
    def candy(self, ratings: List[int]) -> int:
        n = len(ratings)
        candies = n * [1]
        for i in range(1,n):
            if ratings[i] > ratings[i-1]:
                candies[i] = candies[i-1]+1
        for i in range(n-2,-1,-1):
            if ratings[i] > ratings[i+1]:
                candies[i] = max(candies[i+1]+1,candies[i])
        return sum(candies)

class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        change1 = 0
        change2 = 0
        if bills[0] != 5:
            return False
        for i in range(len(bills)):
            if bills[i] == 5:
                change1 += 1
            elif bills[i] == 10 :
                if change1 >= 1:
                    change1 -= 1
                    change2 += 1
                else:
                    return False 
            if bills[i] == 20 :
                if change1 >= 1 and change2 >= 1:
                    change1 -= 1
                    change2 -= 1
                elif change1 >= 3:
                    change1 -= 3
                else :
                    return False 
        return True

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        people.sort(key = lambda x:(-x[0],x[1])) #第一个元素从大到小，第二个元素从小到大
        que = []
        for i in people:
            que.insert(i[1],i) #把排好的元组按照元素2的值插入
        return que

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
    # 先按照h维度的身高顺序从高到低排序。确定第一个维度
        # lambda返回的是一个元组：当-x[0](维度h）相同时，再根据x[1]（维度k）从小到大排序
        people.sort(key=lambda x: (-x[0], x[1]))
        que = []

# 根据每个元素的第二个维度k，贪心算法，进行插入
        # people已经排序过了：同一高度时k值小的排前面。
        for p in people:
            que.insert(p[1], p)
        return que

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        result = []
        for i in range(1,len(prices)):
            if prices[i] -prices[i-1] > 0:
                result.append(prices[i] -prices[i-1])
        return sum(result)

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        cover = 0
        if len(nums) == 1:
            return True
        i = 0
        while i <= cover:
            cover = max(nums[i]+i,cover)
            if cover >= len(nums)-1:
                return True
            i += 1
        return False 

class Solution:
    def jump(self, nums: List[int]) -> int:
        cur = 0
        next = 0
        result = 0
        for i in range(len(nums)-1):
            next = max(i+nums[i],next)
            if i == cur:
                result+=1
                cur = next
                if next >= len(nums)-1 :
                    break
        return result

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort(key = lambda x:abs(x),reverse=True)
        for i in range(len(nums)):
            if k > 0 and nums[i] < 0:
                nums[i] *= -1
                k -=  1
        if k % 2 == 1:
            nums[-1] *= -1
        return sum(nums)

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        index = 0
        result = 0
        for i in range(len(s)):
            if index >= len(g):
                break
            if g[index] <= s[i]:
                index += 1
        return index

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums)
        curdif = 0
        predif = 0
        result = 1
        for i in range(len(nums)-1):
            curdif = nums[i+1] - nums[i]
            if (predif <= 0 and curdif > 0) or (predif >= 0 and curdif < 0):
                result += 1
                predif = curdif
        return result

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        result = float('-inf')
        count = 0
        for i in nums:
            count += i
            if count > result:
                result = count
            if count < 0:
                count = 0
        return result

class Solution:
    def backtracking(self,nums,index,path,result):
        if len(path) > 1:
            result.append(path[:])
        set_ = set()    #!!!!!!进入下一层前重置集合，相当于只在同层里面使用set实现层去重
        for i in range(index,len(nums)):
            if (path and nums[i] < path[-1]) or nums[i] in set_:
                continue
            path.append(nums[i])
            set_.add(nums[i]) #但是往下探索返回的set不会设置成最底下的元素吗
            #不会，我的理解是for循环是分树枝，回溯函数是生长枝条，哦，used在每个函数里被创建，就属于这个函数的局部变量，所以每一层都有自己的used
            self.backtracking(nums,i+1,path,result)
            path.pop()


    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        result = []
        self.backtracking(nums,0,[],result)
        return result

class Solution:
    def backtracking(self,nums,used,path,result):
        if len(path) == len(nums):
            result.append(path[:])
        for i in range (len(nums)):
            if used[i]:
                continue
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums,used,path,result)
            path.pop()
            used[i] = False
    def permute(self, nums: List[int]) -> List[List[int]]:
        result = []
        used = [False]*len(nums)
        self.backtracking(nums,used,[],result)
        return result

class Solution:
    def backtracking(self,nums,used,path,result):
        if len(path) == len(nums):
            result.append(path[:])
        set_ = set()
        for i in range(len(nums)):
            if nums[i] in set_ or used[i]:
                continue
            path.append(nums[i])
            used[i] = True
            set_.add(nums[i])
            self.backtracking(nums,used,path,result)
            used[i] = False
            path.pop()
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        result = []
        used = [False] * len(nums)
        self.backtracking(nums,used,[],result)
        return result

class Solution:
    def isok(self,s,s_index,e_index):
        if s_index > e_index:
            return False
        if s[s_index] == '0' and s_index != e_index:
            return False
        if int(s[s_index:e_index+1]) > 255:
            return False
        return True
    def backtracking(self,s,index,count,cur,result):
        if count == 3 and self.isok(s,index,len(s)-1):
            cur += s[index:]
            result.append(cur)
        for i in range(index,len(s)):
            if self.isok(s,index,i):
                temp = s[index:i+1]
                count += 1
                self.backtracking(s,i+1,count,cur+temp+'.',result) #隐式回溯，cur本身不变
                count -=1

    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s,0,0,'',result)
        return result

class Solution:
    def backtracking(self,nums,index,path,result):
        for i in range(index,len(nums)):
            path.append(nums[i])
            result.append(path[:])
            self.backtracking(nums,i+1,path,result)
            path.pop()

    def subsets(self, nums: List[int]) -> List[List[int]]:
        result = [[]]
        self.backtracking(nums,0,[],result)
        return result

class Solution:
    def backtracking(self,nums,index,path,result,used):
        for i in range(index,len(nums)):
            if i>index and nums[i]==nums[i-1] and not used[i-1]:
                continue 
            path.append(nums[i])
            used[i] = True
            result.append(path[:])
            self.backtracking(nums,i+1,path,result,used)
            path.pop()
            used[i] = False

    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        result = [[]]
        nums.sort()
        used = [False]*len(nums)
        self.backtracking(nums,0,[],result,used)
        return result

class Solution:
    def backtracking(self,candidates,target,sums,index,path,result):
        if sums > target:
            return
        if sums == target:
            result.append(path[:])
            return #空返回，改变result就行

        for i in range(index,len(candidates)):
            sums += candidates[i]
            path.append(candidates[i])
            self.backtracking(candidates,target,sums,i,path,result)
            sums -= candidates[i] 
            path.pop()
        
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        result = []
        self.backtracking(candidates,target,0,0,[],result)
        return result

class Solution:
    def backtracking(self,candidates,target,sums,index,path,result):
        if sums == target:
            result.append(path[:])
            return #空返回，改变result就行

        for i in range(index,len(candidates)):
            sums += candidates[i]
            if sums > target:
                break
            path.append(candidates[i])
            self.backtracking(candidates,target,sums,i,path,result)
            sums -= candidates[i] 
            path.pop()
        
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        result = []
        candidates.sort()
        self.backtracking(candidates,target,0,0,[],result)
        return result

class Solution:
    def backtracking(self,candidates,target,sums,index,used,path,result):
        if sums == target:
            result.append(path[:])
            return 
        for i in range(index,len(candidates)): #用循环让数组的每个变成一棵树的根节点，同时一棵树比一颗更窄，目的就是不要重复（指的是（1，2）（2，1）这种）
            #下面的去重是数组里面本身元素的重复导致的（但是又不能简单的把数组元素去重）
            if i>index and candidates[i] == candidates[i-1] and not used[i-1]: #进行层剪枝的操作
                continue
            sums += candidates[i]
            if sums > target:
                break
            path.append(candidates[i])
            used[i] = True
            self.backtracking(candidates,target,sums,i+1,used,path,result)
            used[i] = False
            sums -= candidates[i]
            path.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        result = []
        used = [False] * len(candidates)
        candidates.sort()
        self.backtracking(candidates,target,0,0,used,[],result)
        return result

class Solution:
    def backtracking(self,s,index,path,result):
        if index == len(s):
            result.append(path[:])
            return 
        for i in range(index,len(s)):
            if s[index:i+1] == s[index:i+1][::-1] :
                path.append(s[index:i+1])
                self.backtracking(s,i+1,path,result)
                path.pop()
    def partition(self, s: str) -> List[List[str]]:
        result = []
        self.backtracking(s,0,[],result)
        return result

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []
        self.backtracking(n,k,1,[],result)
        return result

    def backtracking(self,n,k,index,path,result):
        if len(path) == k:
            result.append(path[:]) # 注意path的拷贝方式
            return
        for i in range(index,n+1):
            path.append(i)
            self.backtracking(n,k,i+1,path,result) #这里改成index+1会返回所有组合（包括重复的）
            path.pop()

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []
        self.backtracking(n,k,1,[],result)
        return result

    def backtracking(self,n,k,index,path,result):
        if len(path) == k:
            result.append(path[:]) # 注意path的拷贝方式
            return
        for i in range(index,n-(k-len(path))+2): # 这里的n-(k-len(path))+2是为了剪枝，因为如果n-(k-len(path))+2还小于k，那么就没有必要继续遍历了
            path.append(i)
            self.backtracking(n,k,i+1,path,result) #这里改成index+1会返回所有组合（包括重复的）
            path.pop()

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        result = []
        self.backtracking(n,k,0,1,[],result)
        return result
    def backtracking(self,targetsum,k,cursum,index,path,result):
        if cursum > targetsum:
            return 
        if len(path) == k :
            if targetsum == cursum:
                result.append(path[:])
            return 
        for i in range(index,9-(k-len(path))+2):
            cursum += i
            path.append(i)
            self.backtracking(targetsum,k,cursum,i+1,path,result)
            cursum -= i
            path.pop()

class Solution:
    def __init__(self):
        self.lettermap=[
            '',
            '',
            'abc',
            'def',
            'ghi',
            'jkl',
            'mno',
            'pqrs',
            'tuv',
            'wxyz'
        ]
        self.result = []
        self.s = ''
    def backtracking(self,digits,index):
        if index == len(digits): #终止条件深度等于位数
            self.result.append(self.s)
            return 
        digit = int(digits[index]) #字符形式转化，便于查字典
        letter = self.lettermap[digit] #对应层的字符串
        for i in letter: #实现分叉
            self.s += i
            self.backtracking(digits,index + 1) #深度探索
            self.s = self.s[:-1] #回溯，删掉最后一个
    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits) == 0:
            return self.result
        self.backtracking(digits,0)
        return self.result

class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if not root:
            return None
        elif root.val < low:
            right = self.trimBST(root.right,low,high)
            return right
        elif root.val > high:
            left = self.trimBST(root.left,low,high)
            return left
        root.left = self.trimBST(root.left,low,high)
        root.right = self.trimBST(root.right,low,high)
        return root

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def tra(nums,left,right):
            if left > right:
                return None
            mid = (left + right)//2
            root = TreeNode(nums[mid])
            root.left =  tra(nums,left,mid-1)
            root.right = tra(nums,mid+1,right)
            return root
        return tra(nums,0,len(nums)-1)

class Solution:
    def __init__(self):
        self.pre = 0
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return 
        self.convertBST(root.right)
        root.val += self.pre 
        self.pre = root.val
        self.convertBST(root.left)
        return root

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root:
            return None
        if root.val > p.val and root.val > q.val:
            left = self.lowestCommonAncestor(root.left,p,q)
            return left 
        if root.val < p.val and root.val < q.val:
            right = self.lowestCommonAncestor(root.right,p,q)
            return right
        return root

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        while root:
            if root.val > p.val and root.val > q.val:
                root = root.left
            elif root.val < p.val and root.val < q.val:
                root = root.right    
            else:
                return root
        return None

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        if root.val > val:
            root.left = self.insertIntoBST(root.left,val)
        else:
            root.right = self.insertIntoBST(root.right,val)
        return root

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root or root.val == val:
            return TreeNode(val)
        if val < root.val:
            if not root.left :
                root.left = TreeNode(val)
            else:
                self.insertIntoBST(root.left,val)
        if val > root.val:
            if not root.right:
                root.right = TreeNode(val)
            else:
                self.insertIntoBST(root.right,val)
        return root

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root:
            return root
        if root.val == key:
            if not root.left and not root.right:
                return None
            elif not root.left:
                return root.right
            elif not root.right:
                return root.left
            else :
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right
        if root.val > key:
            root.left= self.deleteNode(root.left,key)
        if root.val < key:
            root.right= self.deleteNode(root.right,key)
        return root

class Solution:
    def __init__(self):
        self.result = float("inf")
        self.pre = None
    def dfs(self,cur):
        if cur is None:
            return 
        self.dfs(cur.left)
        if self.pre is not None:
            self.result = min(self.result,cur.val-self.pre.val)
        self.pre = cur
        self.dfs(cur.right)
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.dfs(root)
        return self.result

class Solution:
    def __init__(self):
        self.count = 1
        self.pre = None
        self.result = {} 
        return 
    def dfs(self,cur):
        if cur is None:
            return 
        self.dfs(cur.left)
        if self.pre is not None:
            if self.pre.val == cur.val:
                self.count += 1
            else:
                self.count = 1
        self.result[cur.val] = self.count
        self.pre = cur
        self.dfs(cur.right)
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        self.dfs(root)
        target_count = max(self.result.values())
        num = [k for k,v in self.result.items() if v == target_count]
        return num

class Solution:
    def __init__(self):
        self.Maxc = 0
        self.count = 1
        self.pre = None
        self.result = []
        return 
    def dfs(self,cur):
        if cur is None:
            return 
        self.dfs(cur.left)
        if self.pre is None:
            self.count = 1
        elif self.pre.val == cur.val:
            self.count += 1
        else:
            self.count = 1
        self.pre = cur
        if self.count ==self. Maxc:
            self.result.append(cur.val)
        if self.count > self.Maxc:
            self.Maxc = self.count
            self.result = [cur.val]
        self.dfs(cur.right)
        return 
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        self.dfs(root)
        return self.result

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == q or root ==p or root == None:
            return root
        left_ = self.lowestCommonAncestor(root.left,p,q)
        right_ = self.lowestCommonAncestor(root.right,p,q)
        if left_ and right_:
            return root
        elif left_ and not right_:
            return left_
        elif not left_ and right_:
            return right_
        else:
            return None

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 1:     #只有一个点就创建以这个为点的树
            return TreeNode(nums[0])
        node = TreeNode(0) #创建节点设置值为零
        max_n = 0
        index_n = 0
        for i in range(len(nums)):
            if nums[i] > max_n:
                max_n =nums[i]
                index_n = i
        node.val = max_n
        if index_n > 0:
            left_num = nums[0:index_n]
            node.left = self.constructMaximumBinaryTree(left_num)
        if index_n < len(nums)-1:
            right_num = nums[index_n+1:]
            node.right = self.constructMaximumBinaryTree(right_num)
        return node

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if root1 == None:
            return root2
        if root2 == None:
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left,root2.left)
        root1.right = self.mergeTrees(root1.right,root2.right)
        return root1

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root or root.val == val:
            return root
        if val < root.val:
            return self.searchBST(root.left,val)
        if val > root.val:
            return self.searchBST(root.right,val)

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        while root:
            if val < root.val:
                root=root.left
            elif val > root.val:
                root = root.right
            else :
                return root
        return None

class Solution:
    def __init__(self):
        self.pre = None
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        
        if root is None:
            return True
        left = self.isValidBST(root.left)
        if  self.pre is not None and self.pre.val >= root.val:
            return False
        self.pre = root
        right = self.isValidBST(root.right)
        return left and right

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        self.max_ = float('-inf')
        self.result = []
        self.dfs(root,0)
        return self.result

    def dfs(self,node,depth):
        if not node.left and not node.right:
            if depth > self.max_:
                self.max_ = depth
                self.result = node.val
            return 
        if node.left:
            depth += 1
            self.dfs(node.left,depth)
            depth -= 1
        if node.right:
            depth += 1
            self.dfs(node.right,depth)
            depth -= 1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        return self.dfs(root,targetSum-root.val)
    def dfs(self,node,targetSum):
        if not node.left and not node.right and targetSum == 0:
            return True
        if not node.left and not node.right and targetSum != 0:
            return False
        if node.left:
            targetSum -= node.left.val
            if self.dfs(node.left,targetSum):
                return True
            targetSum += node.left.val
        if node.right:
            targetSum -= node.right.val
            if self.dfs(node.right,targetSum):
                return True
            targetSum += node.right.val
        return False

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        self.result = []
        self.path = []
        if not root:
            return self.result
        self.path.append(root.val)
        self.dfs(root,targetSum-root.val)
        return self.result

    def dfs(self,node,targetSum):
        if not node.left and not node.right and targetSum == 0:
            self.result.append(self.path[:])
            return 
        if not node.left and not node.right:
            return 
        if node.left:
            self.path.append(node.left.val)
            targetSum -= node.left.val
            self.dfs(node.left,targetSum)
            targetSum += node.left.val
            self.path.pop() 
        if node.right:
            self.path.append(node.right.val)
            targetSum -= node.right.val
            self.dfs(node.right,targetSum)
            targetSum += node.right.val
            self.path.pop()
        return 

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if not postorder:
            return None
        root_val = postorder[-1]
        root = TreeNode(root_val)

        mid_index = inorder.index(root_val)

        left_in = inorder[:mid_index]
        right_in = inorder[mid_index+1:]

        left_po = postorder[:mid_index]
        right_po = postorder[mid_index:-1]

        root.left = self.buildTree(left_in,left_po)
        root.right = self.buildTree(right_in,right_po)

        return root

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder:
            return None
        root_val = preorder[0]
        root = TreeNode(root_val)
        mid_index = inorder.index(root_val)
        left_in = inorder[:mid_index] 
        right_in = inorder[mid_index+1:]
        left_pr = preorder[1:mid_index+1]
        right_pr = preorder[mid_index+1:]
        root.left = self.buildTree(left_pr,left_in)
        root.right = self.buildTree(right_pr,right_in)
        return root

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if self.get_h(root) == -1:
            return False
        else:
            return True

    def get_h(self,node):
        if not node:
            return 0
        left_h = self.get_h(node.left)
        if left_h == -1:
            return -1
        elif (right_h := self.get_h(node.right)) == -1: #海象运算符
            return -1
        elif abs(left_h - right_h)>1:
            return -1
        else:
            return max(left_h,right_h)+1