#include
#include <vector>

struct Node{
int data;
Node* parent = nullptr;
Node* left = nullptr;
Node* right = nullptr;
};

Node* Build(std::vector<char>& arr) {
Node* root;
for (int i = 0; i < arr.size(); ++i) {
if (arr[i] == ‘l’) {
Node* new_node = new Node;
root->left = new_node;
new_node->parent = root;
root = root->left;
} else if (arr[i] == ‘r’) {
Node* new_node = new Node;
root->right = new_node;
new_node->parent = root;
root = root->right;
} else if (arr[i] == ‘u’) {
if (root->parent != nullptr) {
root = root->parent;
} else {
return root;
}
} else if (isdigit(arr[i])) {
root->data = arr[i] - ‘0’;
}
}
return root;
}

int MaxSumBST(Node* node, int& maxSum) {
if (!node) return 0;

int leftSum = MaxSumBST(node->left, maxSum);
int rightSum = MaxSumBST(node->right, maxSum);
int totalSum = node->data + leftSum + rightSum;

if ((node->left == nullptr || (node->left->data < node->data && node->left == node->left->parent->left)) &&
(node->right == nullptr || (node->right->data > node->data && node->right == node->right->parent->right))) {
maxSum = std::max(maxSum, totalSum);
return totalSum;
}

return 0;
}

int main() {
char cmd;
std::vector<char> arr;
while (std::cin >> cmd) {
arr.push_back(cmd);
}
Node* root = new Node;
root = Build(arr);

int ans = 0;
MaxSumBST(root, ans);
std::cout << ans;
}

вот задача подправь мой код(он почти рабочий однако не проходит второй тест, не реализовани числа больше 9 и отрицательные)

Денис
−
− очень занятой человек. Поэтому он нанял Вас, чтобы оптимизировать свои жизненные процессы.

Самое важное для Дениса
−
− это саморазвитие, из-чего для каждого дня он составляет расписание в виде бинарного дерева, каждая вершина которого
−
− это польза от завершения некоторой работы в течение дня.

Чтобы получать максимальную пользу от каждой минуты своего драгоценного времени, Денис ищет в своем расписании оптимальный участок для работы. Таковым он называет поддерево, которое является BST с максимальной пользой.

Входные данные

�
l
−
− спуск в левого ребёнка

�
r
−
− спуска в правого ребёнка

�
u
−
− подъём наверх

В единственной строке подается
�
n значений.

Выходные данные

Вывести в единственной строке число
−
− максимальную пользу

STDIN STDOUT
1 l 4 l 2 u r 4 u u r 3 l 2 u r 5 l 4 u r 6 u u u u

20

4 l 3 l 1 u r 2 u u u

2

-4 l -2 u r -5 u u

0

Для поддержки значений больше 9 и отрицательных чисел, необходимо считывать числа целиком, а не по одной цифре. Также стоит внимательно проанализировать логику обхода дерева, чтобы убедиться в том, что программа корректно поднимается на уровень вверх.

Перепишем основные части кода, чтобы обработать входные данные корректно:

#include <iostream>
#include <vector>
#include <stack>
#include <string> // Нужно для std::string и std::stoi

struct Node {
    int data;
    Node* parent;
    Node* left;
    Node* right;
    Node(int val = 0, Node* p = nullptr) : data(val), parent§, left(nullptr), right(nullptr) {}
};

// Объявляем функцию MaxSumBST здесь, чтобы её можно было вызвать в Build
int MaxSumBST(Node* node, int& maxSum);

int main() {
    std::stack<Node*> nodes;
    std::string token;
    Node* root = nullptr;

    while (std::cin >> token) {
        if (token == “l” || token == “r”) {
            // Считываем значение для узла
            int value;
            std::cin >> value;
            // Создаем новый узел
            Node* newNode = new Node(value);
            if (!root) {
                root = newNode;
            } else {
                Node* parent = nodes.top();
                if (token == “l”) {
                    parent->left = newNode;
                } else {
                    parent->right = newNode;
                }
                newNode->parent = parent;
            }
            nodes.push(newNode);
        } else if (token == “u” && !nodes.empty()) {
            // Подняться вверх к родителю
            nodes.pop();
        }
    }

    int ans = 0;
    if (root) {
        MaxSumBST(root, ans);
    }
    std::cout << ans << std::endl;

    // Здесь нужно добавить очистку памяти, выделенной для дерева


ты не дописал свой ответ