thảo luận Leetcode mỗi ngày

public class Solution {
    public TreeNode PostOrder(TreeNode root, int target)
    {
        if(root.left != null)
            root.left = PostOrder(root.left, target);
        if(root.right != null)
            root.right = PostOrder(root.right, target);
        if(root.val == target && root.left == null && root.right == null)
            return null;
        else return root;
    }
    public TreeNode RemoveLeafNodes(TreeNode root, int target) {
        root = PostOrder(root, target);
        return root;
    }
}

class Solution {
    public TreeNode removeLeafNodes(TreeNode root, int target) {
        if(root==null) return null;
    
        TreeNode leftNode = removeLeafNodes(root.left,target);
        TreeNode rightNode = removeLeafNodes(root.right, target);
        if(leftNode==null){
            root.left=null;
        }
        if(rightNode==null){
            root.right=null;
        }
        if(leftNode==null&& rightNode==null && root.val==target){
            root=null;
        }
        return root;
    }

}

# Definition for a binary tree node.
# class TreeNode
#     attr_accessor :val, :left, :right
#     def initialize(val = 0, left = nil, right = nil)
#         @val = val
#         @left = left
#         @right = right
#     end
# end
# @param {TreeNode} root
# @param {Integer} target
# @return {TreeNode}
def remove_leaf_nodes(node, target)
    node.left = remove_leaf_nodes(node.left, target) if node.left
    node.right = remove_leaf_nodes(node.right, target) if node.right

    return nil if node.left.nil? && node.right.nil? && node.val == target

    node
end

class Solution {
public:
    TreeNode* removeLeafNodes(TreeNode* node, int target) {
        if (node->left) {
            node->left = removeLeafNodes(node->left, target);
        }

        if (node->right) {
            node->right = removeLeafNodes(node->right, target);
        }

        if (node->left == NULL && node->right == NULL && node->val == target) {
            node->~TreeNode();
            return NULL;
        }

        return node;
    }
};

class Solution {
public:
  TreeNode *removeLeafNodes(TreeNode *root, int target) {
    if (root == NULL)
      return NULL;
    root->left = removeLeafNodes(root->left, target);
    root->right = removeLeafNodes(root->right, target);
    if (root->val == target && root->left == root->right)
      return NULL;
    return root;
  }
};

class Solution:
    def removeLeafNodes(self, root: Optional[TreeNode], target: int) -> Optional[TreeNode]:
        def postOrder(root):
            if not root:
                return None
            root.left = postOrder(root.left)
            root.right = postOrder(root.right)
            if not root.left and not root.right and root.val == target:
                return None
            return root

        return postOrder(root)

class Solution:
    def removeLeafNodes(self, root: Optional[TreeNode], target: int) -> Optional[TreeNode]:
        def removeIfNeeded(node):
            if not node.left and not node.right and node.val == target:
                return None
            return node

        def allDescendantsVisited(node):
            return ((not node.left or node.left in resultMap)
                    and (not node.right or node.right in resultMap))

        st = [root]
        resultMap = {}
        while st:
            curNode = st[-1]
            if allDescendantsVisited(curNode):
                st.pop()
                curNode.left = resultMap.pop(curNode.left, None)
                curNode.right = resultMap.pop(curNode.right, None)
                resultMap[curNode] = removeIfNeeded(curNode)
                continue
        
            if curNode.right:
                st.append(curNode.right)
            if curNode.left:
                st.append(curNode.left)

        return resultMap[root]

var removeLeafNodes = function(root, target) {
    function recursion(node) {
        if (!node) return false;

        if (node.left && recursion(node.left)) node.left = null;
        if (node.right && recursion(node.right)) node.right = null;

        return !node.left && !node.right && node.val === target;
    }

    if (recursion(root)) {
        return null;
    }

    return root;
};

/**
 * Example:
 * var ti = TreeNode(5)
 * var v = ti.`val`
 * Definition for a binary tree node.
 * class TreeNode(var `val`: Int) {
 *     var left: TreeNode? = null
 *     var right: TreeNode? = null
 * }
 */
class Solution {
    fun removeLeafNodes(root: TreeNode?, target: Int): TreeNode? {
         if (root == null) {
            return null
        }
        root.left = removeLeafNodes(root.left, target)
        root.right = removeLeafNodes(root.right, target)
        return if (root.left == null && root.right == null && root.`val` == target) {
            null
        } else {
            root
        }
    }
}

class Solution:
    def distributeCoins(self, root: Optional[TreeNode]) -> int:
        def dfs(node):
            if not node:
                return 0,0,0
            l_num_nodes, l_num_coins, l_num_move = dfs(node.left)
            r_num_nodes, r_num_coins, r_num_move = dfs(node.right)
            num_nodes = l_num_nodes + r_num_nodes + 1
            num_coins = l_num_coins + r_num_coins + node.val
            num_move = abs(l_num_nodes - l_num_coins) + abs(r_num_nodes - r_num_coins) + l_num_move + r_num_move
            return num_nodes, num_coins, num_move
        return dfs(root)[2]

class Solution {
    public int[] divideAndConquer(TreeNode root) {
        if (root == null)
            return new int[]{0, 1};
        int[] lt = divideAndConquer(root.left);
        int[] rt = divideAndConquer(root.right);
        int[] res = new int[2];
        int leftVal = root.left == null ? 1 : root.left.val;
        int rightVal = root.right == null ? 1 : root.right.val;
        res[0] = lt[0] + rt[0] + Math.abs(lt[1] - leftVal) + Math.abs(rt[1] - rightVal);
        res[1] = lt[1] + rt[1] - leftVal - rightVal + 1;
        return res;
    }

    public int distributeCoins(TreeNode root) {
        int[] res = divideAndConquer(root);
        return res[0];
    }
}