LeetCode 968.BinaryTreeCameras monitorea árboles binarios

Enlace de tema

LC.968

responder

Título

emm es como el título ~

Ideas

Definimos "cobertura" como el nodo que se puede monitorear.
Suponga que el nodo tiene tres estados:

1. Descubierto
2. Tener una cámara
3. Se ha sobrescrito.

Para utilizar la menor cantidad de cámaras y monitorear tantos nodos como sea posible, tenemos que instalar cámaras de abajo hacia arriba.
Para completar esta operación, necesitamos utilizar el recorrido posterior al pedido.

Con respecto al estado devuelto, comenzamos desde el nodo hijo del nodo hoja, el nodo vacío.
Para un nodo vacío:

1. Si su estado no está cubierto, entonces es necesario instalar una cámara en su nodo principal, lo que genera desperdicio;
2. Si su estado es una cámara, se cubre el estado de su nodo principal, lo que hace que la cámara se instale en el nodo principal del nodo principal de su nodo principal (grandpa node ~), lo que hace que su nodo principal, el nodo hoja no se pueda instalar. cubrir;
3. Si se cubre su estado, no se cubre el estado de su nodo principal, de modo que la cámara se instala en el nodo principal de su nodo principal, perfecto ~

Por último, es necesario procesar el nodo raíz. Si no se cubre el estado de devolución, el resultado final debe aumentarse en 1.

Código AC

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    int ans = 0;

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

        // 如果有子节点未被覆盖，则需要安摄像头
        if ((left == 0 && right == 0) || (left == 1 && right == 0) || (left == 0 && right == 1) || (left == 0 && right == 2) || (left == 2 && right == 0)) {
    
    
            ans += 1;
            return 1;
        }
        // 如果子节点可以覆盖此处，则返回已覆盖
        if ((left == 1 && right == 2) || (left == 2 && right == 1) || (left == 1 && right == 1)) {
    
    
            return 2;
        }
        // 如果子节点已被覆盖，则此处无需摄像头且未被覆盖
        if ((left == 2 && right == 2)) {
    
    
            return 0;
        }
        return 0;
    }

    int minCameraCover(TreeNode* root) {
    
    
        if (dfs(root) == 0) {
    
    
            ans += 1;
        }
        return ans;
    }
};

posdata

Ah, este es el código que usé dos veces antes. Lo presioné
y lo presioné y descubrí que no había ningún problema, incluso perfecto. Descubrí lo que estaba mal. Era como un QAQ con retraso mental (pero puedo plantear una pregunta que solo monitorea los nodos secundarios hhhhhhhhhh

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    int ans = 0;

    bool dfs(TreeNode *root) {
    
    
        while (root->left != nullptr || root->right != nullptr) {
    
    
            bool son1 = false, son2 = false;
            if (root->left == nullptr || (root->left->left == nullptr && root->left->right == nullptr)) {
    
    
                son1 = true;
            } else {
    
    
                if (dfs(root->left)) root->left = nullptr;
            }
            if (root->right == nullptr || (root->right->right == nullptr && root->right->left == nullptr)) {
    
    
                son2 = true;
            } else {
    
    
                if (dfs(root->right)) root->right = nullptr;
            }
            if (son1 && son2) {
    
    
                ans += 1;
                return true;
            }
        }
        return false;
    }
    
    int minCameraCover(TreeNode* root) {
    
    
        if (root -> left == nullptr && root -> right == nullptr) return 1;
        else if (root == nullptr) return 0;
        dfs(root);
        return ans;
    }
};