I have the following problem

Maximum Path Weights in Binary Trees

Overview:

In this lab, my task is finding the maximum path weight in a binary tree, where each node has three attributes:

A pointer to the left subtree.

A pointer to the right subtree.

The weight of the node $($an integer, potentially negative$).$

The weight of a path in the tree is defined as the sum of the weights of the nodes along that path. A maximum path is one with the highest possible weight.

Problem:

Given a binary tree T$,$ the objective is to find the maximum weight of a path in T$.$ Special cases include trees where all node weights are zero or negative, in which the maximum path would be empty or consist only of nodes with zero weight.

Input Specification:

The binary tree is provided as a sequence S$,$ which recursively defines the structure of the tree using:

p: the weight of the root node, ranging from $-10^4$ to $10^4.$

flagE and flagD: flags indicating whether the left or right subtrees exist $($T for true, F for false$).$

An example of such a sequence could be:

$4$ F F $($single node tree$).$

$4$ T $7$ F F T $-3$ F F $($tree with both left and right subtrees$).$

The number of nodes is guaranteed to be between $1$ and $100,000.$

Output Specification:

The output should be the maximum path weight in the binary tree.

Examples:

Input: $4$ F F

Output: $4$

Input: $4$ T $7$ F F T $-3$ F F

Output: $11$

I have the following code

class TreeNode:

def $\_\_$init$\_\_($self$,$ weight, left$=$None, right$=$None$)$:

self.weight $=$ weight

self.left $=$ left

self.right $=$ right

class BinaryTree:

def $\_\_$init$\_\_($self$,$ sequence$)$:

self.sequence $=$ sequence

self.index $=0$

def build$\_$tree$($self$)$:

return self.$\_$helper$()$

def $\_$helper$($self$)$:

if self.index $>=$ len$($self$.$sequence$)$:

return None, self.index

# Primeiro, processamos o peso do n$,$ que deve ser um n$$mero

current$\_$value $=$ self.sequence$[$self$.$index$]$

# Garante que o valor atual seja um n$$mero

if current$\_$value not in $[\text{'}$T$\text{'},\text{'}$F$\text{'}]$:

try:

weight $=$ int$($current$\_$value$)$ # Converte o valor para inteiro

except ValueError:

raise ValueError$($f$"$Erro ao converter $\text{'}\{$current$\_$value$\}\text{'}$ para int. Esperado um n$$mero$.")$

else:

raise ValueError$($f$"$Esperado um n$$mero$,$ mas encontrado $\text{'}\{$current$\_$value$\}\text{'}.$ Verifique a sequ$$ncia$.")$

self.index $+=1$

# Processa as flags $\text{'}$T$\text{'}$ ou $\text{'}$F$\text{'}$ para as sub$$rvores

flagE $=$ self.sequence$[$self$.$index$]$

self.index $+=1$

flagD $=$ self.sequence$[$self$.$index$]$

self.index $+=1$

left$\_$subtree $=$ None

right$\_$subtree $=$ None

if flagE $==\text{'}$T$\text{'}$: # Se for $\text{'}$T$\text{'},$ h$$ sub$$rvore $$ esquerda

left$\_$subtree, $\_=$ self.$\_$helper$()$

if flagD $==\text{'}$T$\text{'}$: # Se for $\text{'}$T$\text{'},$ h$$ sub$$rvore $$ direita

right$\_$subtree, $\_=$ self.$\_$helper$()$

# Retorna o n$$ atual com suas sub$$rvores

return TreeNode$($weight$,$ left$\_$subtree, right$\_$subtree$),$ self.index

def print$\_$tree$($self$,$ node, level$=0)$:

if node is not None:

self.print$\_$tree$($node$.$right, level $+1)$

print$(\text{'}\text{'}*4*$ level $+\text{'}->\text{'},$ node.weight$)$

self.print$\_$tree$($node$.$left, level $+1)$

class PathSumCalculator:

def max$\_$path$\_$sum$($self$,$ root$)$:

def helper$($node$)$:

if not node:

return $0$

# Calcula os caminhos m$$ximos $$ esquerda e $$ direita

left$\_$max $=$ max$(0,$ helper$($node$.$left$))$

right$\_$max $=$ max$(0,$ helper$($node$.$right$))$

# Atualiza o caminho m$$ximo global

current$\_$max $=$ node.weight $+$ left$\_$max $+$ right$\_$max

helper.max$\_$sum $=$ max$($helper$.$max$\_$sum, current$\_$max$)$

# Retorna o valor m$$ximo para um dos lados $($esquerda ou direita$)$

return node.weight $+$ max$($left$\_$max, right$\_$max$)$

helper.max$\_$sum $=$ float$(\text{'}-$inf'$)$

helper$($root$)$

return max$(0,$ helper.max$\_$sum$)$

def main$()$:

# Substitui sinais de menos especiais e divide a sequ$$ncia

sequence $=$ input$("$Enter the tree sequence: $").$replace$(\text{'}\text{'},\text{'}-\text{'}).$replace$(\text{'}\text{'},\text{'}-\text{'}).$split$()$

try:

binary$\_$tree $=$ BinaryTree$($sequence$)$

tree, $\_=$ binary$\_$tree.build$\_$tree$()$

except $($ValueError$,$ IndexError$)$ as e:

print$($f$"$Erro na constru$$o da $$rvore: $\{$e$\}")$

return

if tree:

print$("$Estrutura da $$rvore:$")$

binary$\_$tree.print$\_$tree$($tree$)$

calculator $=$ PathSumCalculator$()$

result $=$ calculator.max$\_$path$\_$sum$($tree$)$

print$("$Maximum path sum:", result$)$

else:

print$("$Constru$$o da $$rvore falhou."$)$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

main$()$

and I$\text{'}$m having the following error

ERROR: Error in tree construction: Expected a number, but found $\text{'}$F$\text{'}.$ Check the sequence.