Pregunta diaria de Leetcode: 1448. Cuente el número de nodos buenos en un árbol binario

Titulo original

Dado un  root árbol binario con raíz, devuelva la cantidad de nodos buenos en el árbol binario.

El "buen nodo" X se define como: entre los nodos que pasan de la raíz al nodo X, ningún valor de nodo es mayor que el valor de X.

Ejemplo 1:

Entrada: raíz = [3,1,4,3,null,1,5]
 Salida: 4
 Explicación: El nodo azul en el gráfico es un buen nodo. 
El nodo raíz (3) siempre es un buen nodo. 
El nodo 4 -> (3,4) es el valor máximo en la ruta. 
El nodo 5 -> (3,4,5) es el valor máximo en la ruta. 
Nodo 3 -> (3,1,3) es el valor máximo en la ruta.

Ejemplo 2:

Entrada: raíz = [3,3,null,4,2]
 Salida: 3
 Explicación: El nodo 2 -> (3, 3, 2) no es un buen nodo porque "3" es más grande que él.

Ejemplo 3:

Entrada: raíz = [1]
 Salida: 1
 Explicación: El nodo raíz es un buen nodo.

pista:

• El rango del número de nodos en un árbol binario es  [1, 10^5] .
• El rango del peso de cada nodo es  [-10^4, 10^4] .

Ideas para resolver problemas

Obviamente, necesitamos atravesar cada nodo y pasar juntos el valor máximo en la ruta actual. Este es un problema relacionado con la profundidad de la ruta. Considere usar DFS para implementar el recorrido:

class Solution {
public:
    int goodNodes(TreeNode* root) {
        return dfs(root);
    }

    void dfs(TreeNode* root) {
        if(root == nullptr){
            return;
        }
        visit(root);
        dfs(root->left);
        dfs(root->right);
    }
};

 Supongamos que actualmente tenemos una raíz de nodo y el valor máximo path_max de la ruta cargada. Si el valor del nodo actual es menor que path_max, continuamos pasando path_max a sus nodos izquierdo y derecho. Si el valor del nodo actual es mayor que path_max, establezca path_max en el valor del nodo actual y pase path_max a sus nodos izquierdo y derecho. El número de nodos buenos del nodo actual es igual a la suma del número de nodos de los nodos izquierdo y derecho, más 1, si el nodo actual es un nodo bueno; de lo contrario, no se suma. Teniendo en cuenta que el nodo raíz debe ser un buen nodo, podemos usar INT_MIN como valor inicial de path_max. Entonces obtenemos la implementación completa:

class Solution {
public:
    int goodNodes(TreeNode* root) {
        return dfs(root,INT_MIN);
    }

    void dfs(TreeNode* root, int path_max) {
        if(root == nullptr){
            return 0;
        }
        int res = 0;
        if(root->val >= path_max){
            res++;
            path_max = root->val;
        }
        res += dfs(root->left, path_max);
        res += dfs(root->right, path_max);
        return res;
    }
};