Return an integer denoting the size of the kth largest perfect binary 

subtree, or -1 if it doesn’t exist.

A perfect binary tree is a tree where all leaves are on the same level, and every parent has two children.

Example 1:

Input: root = [5,3,6,5,2,5,7,1,8,null,null,6,8], k = 2

Output: 3

Explanation:

The roots of the perfect binary subtrees are highlighted in black. Their sizes, in decreasing order are [3, 3, 1, 1, 1, 1, 1, 1].
The 2nd largest size is 3.

Example 2:

Input: root = [1,2,3,4,5,6,7], k = 1

Output: 7

Explanation:

The sizes of the perfect binary subtrees in decreasing order are [7, 3, 3, 1, 1, 1, 1]. The size of the largest perfect binary subtree is 7.

Example 3:

Input: root = [1,2,3,null,4], k = 3

Output: -1

Explanation:

The sizes of the perfect binary subtrees in decreasing order are [1, 1]. There are fewer than 3 perfect binary subtrees.

Constraints:

• The number of nodes in the tree is in the range [1, 2000].
• 1 <= Node.val <= 2000
• 1 <= k <= 1024

Solution: DFS

Write a function f() to return the perfect subtree size at node n.

def f(TreeNode n):
if not n: return 0
l, r = f(n.left), f(n.right)
return l + r + 1 if l == r && l != -1 else -1

Time complexity: O(n + KlogK)
Space complexity: O(n)

class Solution {
public:
  int kthLargestPerfectSubtree(TreeNode* root, int k) {
    vector<int> ss;
    function<int(TreeNode*)> PerfectSubtree = [&](TreeNode* node) -> int {
      if (node == nullptr) return 0;
      int l = PerfectSubtree(node->left);
      int r = PerfectSubtree(node->right);
      if (l == r && l != -1) {
        ss.push_back(l + r + 1);
        return ss.back();
      }
      return -1;  
    };
    PerfectSubtree(root);
    sort(rbegin(ss), rend(ss));
    return k <= ss.size() ? ss[k - 1] : -1;
  }
};

The post 花花酱 LeetCode 3319. K-th Largest Perfect Subtree Size in Binary Tree appeared first on Huahua's Tech Road.

If node i has no left child then leftChild[i] will equal -1, similarly for the right child.

Note that the nodes have no values and that we only use the node numbers in this problem.

Example 1:

Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1]
Output: true

Example 2:

Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,3,-1,-1]
Output: false

Example 3:

Input: n = 2, leftChild = [1,0], rightChild = [-1,-1]
Output: false

Example 4:

Input: n = 6, leftChild = [1,-1,-1,4,-1,-1], rightChild = [2,-1,-1,5,-1,-1]
Output: false

Constraints:

• 1 <= n <= 10^4
• leftChild.length == rightChild.length == n
• -1 <= leftChild[i], rightChild[i] <= n - 1

Solution: Count in-degrees for each node

in degree must <= 1 and there must be exact one node that has 0 in-degree.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
    vector<int> in(n);
    for (int l : leftChild) if (l >= 0) ++in[l];
    for (int r : rightChild) if (r >= 0) ++in[r];
    int zero = 0;
    for (int i = 0; i < n; ++i) {
      if (in[i] > 1) return false;
      if (in[i] == 0) ++zero;
    }
    // # of nodes without parent must be 1.
    return zero == 1;
  }
};

The post 花花酱 LeetCode 1361. Validate Binary Tree Nodes appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/house-robber-iii/description/

The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the “root.” Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that “all houses in this place forms a binary tree”. It will automatically contact the police if two directly-linked houses were broken into on the same night.

Determine the maximum amount of money the thief can rob tonight without alerting the police.

Example 1:

     3
    / \
   2   3
    \   \ 
     3   1

Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.

Example 2:

     3
    / \
   4   5
  / \   \ 
 1   3   1

Maximum amount of money the thief can rob = 4 + 5 = 9.

Idea: 

Compare grandparent + max of grandchildren(l.l + l.r + r.l + r.r) vs max of children (l + r)

Solution 1: Recursion w/o memorization 

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 1289 ms
class Solution {
public:
  int rob(TreeNode* root) {
    if (root == nullptr) return 0;
    int val = root->val;
    int ll = root->left ? rob(root->left->left) : 0;
    int lr = root->left ? rob(root->left->right) : 0;
    int rl = root->right ? rob(root->right->left) : 0;
    int rr = root->right ? rob(root->right->right) : 0;
    return max(val + ll + lr + rl + rr, rob(root->left) + rob(root->right));
  }
};

Solution 2: Recursion w/ memorization 

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 15 ms
class Solution {
public:
  int rob(TreeNode* root) {
    if (root == nullptr) return 0;
    if (m_.count(root)) return m_[root];
    int val = root->val;
    int ll = root->left ? rob(root->left->left) : 0;
    int lr = root->left ? rob(root->left->right) : 0;
    int rl = root->right ? rob(root->right->left) : 0;
    int rr = root->right ? rob(root->right->right) : 0;
    return m_[root] = max(val + ll + lr + rl + rr, rob(root->left) + rob(root->right));
  }
private:
  unordered_map<TreeNode*, int> m_;
};

Solution 3: Recursion return children’s value

// Author: Huahua
// Running time: 10 ms (beats 97.57%)
class Solution {
public:
  int rob(TreeNode* root) {
    int l = 0;
    int r = 0;
    return rob(root, l, r);    
  }
private:
  // return rob(root) and stores rob(root->left/right) in l/r.
  int rob(TreeNode* root, int& l, int& r) {
    if (root == nullptr) return 0;
    int ll = 0;
    int lr = 0;
    int rl = 0;
    int rr = 0;
    l = rob(root->left, ll, lr);
    r = rob(root->right, rl, rr);    
    return max(root->val + ll + lr + rl + rr, l + r);
  }
};

Python3

"""
Author: Huahua
Running time: 64 ms (beats 93.18%)
"""
class Solution:
  def rob(self, root):
    def rob(root):
      if not root: return 0, 0, 0
      l, ll, lr = rob(root.left)
      r, rl, rr = rob(root.right)
      return max(root.val + ll + lr + rl + rr, l + r), l, r
    
    return rob(root)[0]

Related Problems:

• 花花酱 LeetCode 198. House Robber

The post 花花酱 LeetCode 337. House Robber III appeared first on Huahua's Tech Road.

Problem:

Given a binary tree, return the postorder traversal of its nodes’ values.

For example:
Given binary tree {1,#,2,3},

1
    \
     2
    /
   3

return [3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

Solution 1:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;        
        postorderTraversal(root, ans);
        return ans;
    }
    
    void postorderTraversal(TreeNode* root, vector<int>& ans) {
        if (!root) return;
        postorderTraversal(root->left, ans);
        postorderTraversal(root->right, ans);
        ans.push_back(root->val);
    }
};

Solution 2:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> ans;
        const vector<int> l = postorderTraversal(root->left);
        const vector<int> r = postorderTraversal(root->right);
        ans.insert(ans.end(), l.begin(), l.end());
        ans.insert(ans.end(), r.begin(), r.end());
        ans.push_back(root->val);
        return ans;
    }
};

Solution 3:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        deque<int> ans;
        stack<TreeNode*> s;
        s.push(root);
        while (!s.empty()) {
            TreeNode* n = s.top();
            s.pop();
            ans.push_front(n->val); // O(1)
            if (n->left) s.push(n->left);
            if (n->right) s.push(n->right);
        }   
        return vector<int>(ans.begin(), ans.end());
    }
};

The post 花花酱 LeetCode 145. Binary Tree Postorder Traversal appeared first on Huahua's Tech Road.

Problem:

Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.

Example 1:

<b>Input:</b>
    3
   / \
  9  20
    /  \
   15   7
<b>Output:</b> [3, 14.5, 11]
<b>Explanation:</b>
The average value of nodes on level 0 is 3,  on level 1 is 14.5, and on level 2 is 11. 
Hence return [3, 14.5, 11].

Time Complexity:

O(n)

Space Complexity:

O(h)

Solution 1:

BFS

// Author: Huahua
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        if(root == nullptr) return {};
        vector<double> ans;
        vector<TreeNode*> curr, next;
        curr.push_back(root);
        
        // process every level one by one
        while(!curr.empty()) {
            long long sum = 0;
            for(const auto& node : curr) {
                sum += node->val;
                if (node->left) next.push_back(node->left);
                if (node->right) next.push_back(node->right);
            }
            
            ans.push_back(static_cast<double>(sum) / curr.size());
            
            curr.swap(next);
            next.clear();
        }
        
        return ans;
    }
};

Solution 2:

DFS

// Author: Huahua
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        if(root == nullptr) return {};
        vector<pair<long long, int>> sum_count;
        vector<double> ans;
        preorder(root, 0, sum_count);
        for(const auto& p : sum_count)
            ans.push_back(static_cast<double>(p.first) / p.second);
        return ans;
    }
    
private:
    void preorder(TreeNode* root, int depth, vector<pair<long long, int>>& sum_count) {
        if(root == nullptr) return;
        if(depth>=sum_count.size()) sum_count.push_back({0,0});
        sum_count[depth].first += root->val;
        ++sum_count[depth].second;
        preorder(root->left, depth+1, sum_count);
        preorder(root->right, depth+1, sum_count);
    }
};

Related Problems:

• [解题报告] LeetCode 102. Binary Tree Level Order Traversal

The post 花花酱 LeetCode 637. Average of Levels in Binary Tree appeared first on Huahua's Tech Road.

Given an integer array with no duplicates. A maximum tree building on this array is defined as follow:

1. The root is the maximum number in the array.
2. The left subtree is the maximum tree constructed from left part subarray divided by the maximum number.
3. The right subtree is the maximum tree constructed from right part subarray divided by the maximum number.

Construct the maximum tree by the given array and output the root node of this tree.

Example 1:

Input: [3,2,1,6,0,5]
Output: return the tree root node representing the following tree:

      6
    /   \
   3     5
    \    / 
     2  0   
       \
        1

Idea:

Recursion

Solution:

With copy

Time complexity: O(nlogn) ~ O(n^2)

Space complexity: O(nlogn) ~ O(n^2)

running time 79ms

// Author: Huahua
class Solution {
public:    
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.empty()) return nullptr;
        auto it = std::max_element(nums.begin(), nums.end());
        TreeNode* root=new TreeNode(*it);
        vector<int> left(nums.begin(), it);
        vector<int> right(it+1, nums.end());
        root->left = constructMaximumBinaryTree(left);
        root->right = constructMaximumBinaryTree(right);
        return root;
    }
}

Without copy

Time complexity: O(nlogn) ~ O(n^2)

Space complexity: O(logn) ~ O(n)

running time 66ms

// Author: Huahua
class Solution {
public:            
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return makeMBT(nums, 0, nums.size());
    }
private:
    TreeNode* makeMBT(const vector<int>& nums, int begin, int end) {
        if(begin>=end) return nullptr;
        auto it = std::max_element(nums.begin() + begin, nums.begin() + end);
        TreeNode* root=new TreeNode(*it);
        int index = it - nums.begin();
        root->left = makeMBT(nums, begin, index);
        root->right = makeMBT(nums, index+1, end);
        return root;
    }
};

The post 花花酱 LeetCode 654. Maximum Binary Tree appeared first on Huahua's Tech Road.

Given a binary search tree and the lowest and highest boundaries as L and R, trim the tree so that all its elements lies in [L, R] (R >= L). You might need to change the root of the tree, so the result should return the new root of the trimmed binary search tree.

Example 1:

Input:
    1
   / \
  0   2

  L = 1
  R = 2

Output: 
    1
      \
       2

Example 2:

Input:
    3
   / \
  0   4
   \
    2
   /
  1

  L = 1
  R = 3

Output:
      3
     / 
   2   
  /
 1

This problem can be solved with recursion

There 3 cases in total depends on the root value and L, R

Time complexity: O(n)

Space complexity: O(1)

Solution:

// Author: Huahua
class Solution {
public:
    // No cleanup -> memory leak 
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        if(!root) return nullptr;
        // val not in range, return the left/right subtrees
        if(root->val < L) return trimBST(root->right, L, R);
        if(root->val > R) return trimBST(root->left, L, R);
        // val in [L, R], recusively trim left/right subtrees
        root->left = trimBST(root->left, L, R);
        root->right = trimBST(root->right, L, R);
        return root;
    }
};

The previous solution has potential memory leak for languages without garbage collection.

Here’s the full program to delete trimmed nodes.

// Author: Huahua
#include <iostream>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
 
class Solution {
public:
    
    // With cleanup -> no memory leak
    TreeNode*& trimBST(TreeNode*& root, int L, int R) {
        if(!root) return root;
        
        if(root->val < L) {            
            auto& result = trimBST(root->right, L, R);
            deleteTree(root->left);
            delete root;
            root=nullptr;
            return result;
        } else if(root->val > R) {
            auto& result = trimBST(root->left, L, R);
            deleteTree(root->right);
            delete root;
            root=nullptr;
            return result;
        } else {
            // recusively trim left/right subtrees
            root->left = trimBST(root->left, L, R);
            root->right = trimBST(root->right, L, R);
            return root;
        }
    }
    
    void deleteTree(TreeNode* &root) {
        if(!root) return;
        deleteTree(root->left);
        deleteTree(root->right);
        delete root;
        root=nullptr;
    }
};

void PrintTree(TreeNode* root) {
    if(!root) {
        cout<<"null ";
        return;
    };
    if(!root->left && !root->right) {
        cout<<root->val<<" ";
    } else {
        cout<<root->val<<" ";
        PrintTree(root->left);
        PrintTree(root->right);
    }
}


int main()
{
    TreeNode* root=new TreeNode(2);
    root->left=new TreeNode(1);
    root->right=new TreeNode(3);
    PrintTree(root);
    std::cout<<std::endl;
    
    TreeNode* t = Solution().trimBST(root, 3, 4);
    PrintTree(t);
    std::cout<<std::endl;

    // Original root was deleted
    PrintTree(root);
    std::cout<<std::endl;
    
    return 0;
}

Example output

2 1 3 
3 
null

The post 花花酱 LeetCode 669. Trim a Binary Search Tree appeared first on Huahua's Tech Road.

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

Solution 1: BFS O(n)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> ans;
        vector<TreeNode*> curr,next;
        curr.push_back(root);
        while(!curr.empty()) {
            ans.push_back({});
            for(TreeNode* node : curr) {
                ans.back().push_back(node->val);
                if(node->left) next.push_back(node->left);
                if(node->right) next.push_back(node->right);
            }
            curr.swap(next);
            next.clear();
        }
        return ans;
    }
};

Solution 2: DFS O(n)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        DFS(root, 0 /* depth */, ans);
        return ans;
    }
private:
    void DFS(TreeNode* root, int depth, vector<vector<int>>& ans) {
        if(!root) return;
        // Works with pre/in/post order
        while(ans.size()<=depth) ans.push_back({});
        ans[depth].push_back(root->val); // pre-order
        DFS(root->left, depth+1, ans);        
        DFS(root->right, depth+1, ans);   
    }
};

The post 花花酱 LeetCode 102. Binary Tree Level Order Traversal appeared first on Huahua's Tech Road.

Solution 1: O(nlogn)

// Author: Huahua
// O(nlogn)
class Solution {
Solution 1: O(nlogn)
public:
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        int left_height = height(root->left);
        int right_height = height(root->right);
        return (abs(left_height - right_height)<=1) && isBalanced(root->left) && isBalanced(root->right);
    }
private:
    int height(TreeNode* root) {
        if(!root) return 0;
        return max(height(root->left), height(root->right))+1;
    }
};

Solution 2: O(n)

// Author: Huahua
// O(n)
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        bool balanced = true;
        height(root, &balanced);
        return balanced;
    }
private:
    int height(TreeNode* root, bool* balanced) {
        if(!root) return 0;
        int left_height = height(root->left, balanced);
        if(!balanced) return -1;
        int right_height = height(root->right, balanced);
        if(!balanced) return -1;
        if(abs(left_height-right_height)>1) {
            *balanced = false;
            return -1;
        }
        return max(left_height, right_height) + 1;
    }
};

Java

// Author: Huahua
// Running time: 1 ms
class Solution {
  private boolean balanced;
  
  private int height(TreeNode root) {
    if (root == null || !this.balanced) return -1;
    int l = height(root.left);
    int r = height(root.right);
    if (Math.abs(l - r) > 1) {
      this.balanced = false;
      return -1;
    }
    return Math.max(l, r) + 1;
  }
  
  public boolean isBalanced(TreeNode root) {
    this.balanced = true;
    height(root);
    return this.balanced;
  }
}

Python

"""
Author: Huahua
Running time: 76 ms
"""
class Solution:
  def isBalanced(self, root):
    self.balanced = True
    def height(root):
      if not root or not self.balanced: return -1
      l = height(root.left)
      r = height(root.right)
      if abs(l - r) > 1:
        self.balanced = False
        return -1
      return max(l, r) + 1
    height(root)
    return self.balanced

The post 花花酱 LeetCode 110. Balanced Binary Tree appeared first on Huahua's Tech Road.