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.

The level sum in the tree is the sum of the values of the nodes that are on the same level.

Return the kth largest level sum in the tree (not necessarily distinct). If there are fewer than k levels in the tree, return -1.

Note that two nodes are on the same level if they have the same distance from the root.

Example 1:

Input: root = [5,8,9,2,1,3,7,4,6], k = 2
Output: 13
Explanation: The level sums are the following:
- Level 1: 5.
- Level 2: 8 + 9 = 17.
- Level 3: 2 + 1 + 3 + 7 = 13.
- Level 4: 4 + 6 = 10.
The 2nd largest level sum is 13.

Example 2:

Input: root = [1,2,null,3], k = 1
Output: 3
Explanation: The largest level sum is 3.

Constraints:

• The number of nodes in the tree is n.
• 2 <= n <= 105
• 1 <= Node.val <= 106
• 1 <= k <= n

Solution: DFS + Sorting

Use DFS to traverse the tree and accumulate level sum. Once done, sort the level sums and find the k-th largest one.

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

Note: sum can be very large, use long long.

// Author: Huahua
class Solution {
public:
  long long kthLargestLevelSum(TreeNode* root, int k) {
    vector<long long> sums;
    function<void(TreeNode*, int)> dfs = [&](TreeNode* root, int d) {
      if (!root) return;
      while (d >= sums.size()) sums.push_back(0);
      sums[d] += root->val;
      dfs(root->left, d + 1);
      dfs(root->right, d + 1);
    };
    dfs(root, 0);
    if (sums.size() < k) return -1;
    sort(rbegin(sums), rend(sums));
    return sums[k - 1];
  }
};

The post 花花酱 LeetCode 2583. Kth Largest Sum in a Binary Tree appeared first on Huahua's Tech Road.

You are given an array words of size n consisting of non-empty strings.

We define the score of a string word as the number of strings words[i] such that word is a prefix of words[i].

• For example, if words = ["a", "ab", "abc", "cab"], then the score of "ab" is 2, since "ab" is a prefix of both "ab" and "abc".

Return an array answer of size n where answer[i] is the sum of scores of every non-empty prefix of words[i].

Note that a string is considered as a prefix of itself.

Example 1:

Input: words = ["abc","ab","bc","b"]
Output: [5,4,3,2]
Explanation: The answer for each string is the following:
- "abc" has 3 prefixes: "a", "ab", and "abc".
- There are 2 strings with the prefix "a", 2 strings with the prefix "ab", and 1 string with the prefix "abc".
The total is answer[0] = 2 + 2 + 1 = 5.
- "ab" has 2 prefixes: "a" and "ab".
- There are 2 strings with the prefix "a", and 2 strings with the prefix "ab".
The total is answer[1] = 2 + 2 = 4.
- "bc" has 2 prefixes: "b" and "bc".
- There are 2 strings with the prefix "b", and 1 string with the prefix "bc".
The total is answer[2] = 2 + 1 = 3.
- "b" has 1 prefix: "b".
- There are 2 strings with the prefix "b".
The total is answer[3] = 2.

Example 2:

Input: words = ["abcd"]
Output: [4]
Explanation:
"abcd" has 4 prefixes: "a", "ab", "abc", and "abcd".
Each prefix has a score of one, so the total is answer[0] = 1 + 1 + 1 + 1 = 4.

Constraints:

• 1 <= words.length <= 1000
• 1 <= words[i].length <= 1000
• words[i] consists of lowercase English letters.

Solution: Trie

Insert all the words into a tire whose node val is the number of substrings that have the current prefix.

During query time, sum up the values along the prefix path.

Time complexity: O(sum(len(word))
Space complexity: O(sum(len(word))

// Author: Huahua
struct Trie {
  Trie* ch[26] = {};
  int cnt = 0;
  void insert(string_view s) {
    Trie* cur = this;
    for (char c : s) {
      if (!cur->ch[c - 'a']) 
        cur->ch[c - 'a'] = new Trie();
      cur = cur->ch[c - 'a'];
      ++cur->cnt;
    }
  }
  int query(string_view s) {
    Trie* cur = this;
    int ans = 0;
    for (char c : s) {
      cur = cur->ch[c - 'a'];
      ans += cur->cnt;
    }
    return ans;
  }
};
class Solution {
public:
  vector<int> sumPrefixScores(vector<string>& words) {
    Trie* root = new Trie();
    for (const string& w : words)
      root->insert(w);
    vector<int> ans;
    for (const string& w : words)
      ans.push_back(root->query(w));
    return ans;
  }
};

The post 花花酱 LeetCode 2416. Sum of Prefix Scores of Strings appeared first on Huahua's Tech Road.

Note:

• The average of n elements is the sum of the n elements divided by n and rounded down to the nearest integer.
• A subtree of root is a tree consisting of root and all of its descendants.

Example 1:

Input: root = [4,8,5,0,1,null,6]
Output: 5
Explanation: 
For the node with value 4: The average of its subtree is (4 + 8 + 5 + 0 + 1 + 6) / 6 = 24 / 6 = 4.
For the node with value 5: The average of its subtree is (5 + 6) / 2 = 11 / 2 = 5.
For the node with value 0: The average of its subtree is 0 / 1 = 0.
For the node with value 1: The average of its subtree is 1 / 1 = 1.
For the node with value 6: The average of its subtree is 6 / 1 = 6.

Example 2:

Input: root = [1]
Output: 1
Explanation: For the node with value 1: The average of its subtree is 1 / 1 = 1.

Constraints:

• The number of nodes in the tree is in the range [1, 1000].
• 0 <= Node.val <= 1000

Solution: Recursion

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

// Author: Huahua
class Solution {
public:
  int averageOfSubtree(TreeNode* root) {    
    // Returns {sum(val), sum(node), ans}
    function<tuple<int, int, int>(TreeNode*)> getSum 
      = [&](TreeNode* root) -> tuple<int, int, int> {
      if (!root) return {0, 0, 0};
      auto [lv, lc, la] = getSum(root->left);
      auto [rv, rc, ra] = getSum(root->right);
      int sum = lv + rv + root->val;
      int count = lc + rc + 1;
      int ans = la + ra + (root->val == sum / count);
      return {sum, count, ans};
    };    
    return get<2>(getSum(root));
  }
};

The post 花花酱 LeetCode 2265. Count Nodes Equal to Average of Subtree appeared first on Huahua's Tech Road.

Return an integer array answer of size n, where answer[i] is the number of flowers that are in full bloom when the ith person arrives.

Example 1:

Input: flowers = [[1,6],[3,7],[9,12],[4,13]], persons = [2,3,7,11]
Output: [1,2,2,2]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

Example 2:

Input: flowers = [[1,10],[3,3]], persons = [3,3,2]
Output: [2,2,1]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

Constraints:

• 1 <= flowers.length <= 5 * 104
• flowers[i].length == 2
• 1 <= starti <= endi <= 109
• 1 <= persons.length <= 5 * 104
• 1 <= persons[i] <= 109

Solution: Prefix Sum + Binary Search

Use a treemap to store the counts (ordered by time t), when a flower begins to bloom at start, we increase m[start], when it dies at end, we decrease m[end+1]. prefix_sum[t] indicates the # of blooming flowers at time t.

For each people, use binary search to find the latest # of flowers before his arrival.

Time complexity: O(nlogn + mlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<int> fullBloomFlowers(vector<vector<int>>& flowers, vector<int>& persons) {
    map<int, int> m{{0, 0}};
    for (const auto& f : flowers)
      ++m[f[0]], --m[f[1] + 1];    
    int sum = 0;
    for (auto& [t, c] : m)
      c = sum += c;    
    vector<int> ans;    
    for (int t : persons)      
      ans.push_back(prev(m.upper_bound(t))->second);
    return ans;
  }
};

The post 花花酱 LeetCode 2251. Number of Flowers in Full Bloom appeared first on Huahua's Tech Road.

Return true if the value of the root is equal to the sum of the values of its two children, or false otherwise.

Example 1:

Input: root = [10,4,6]
Output: true
Explanation: The values of the root, its left child, and its right child are 10, 4, and 6, respectively.
10 is equal to 4 + 6, so we return true.

Example 2:

Input: root = [5,3,1]
Output: false
Explanation: The values of the root, its left child, and its right child are 5, 3, and 1, respectively.
5 is not equal to 3 + 1, so we return false.

Constraints:

• The tree consists only of the root, its left child, and its right child.
• -100 <= Node.val <= 100

Solution:

Just want to check whether you know binary tree or not.

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool checkTree(TreeNode* root) {
    return root->val == root->left->val + root->right->val;
  }
};

The post 花花酱 LeetCode 2236. Root Equals Sum of Children appeared first on Huahua's Tech Road.

• If isLefti == 1, then childi is the left child of parenti.
• If isLefti == 0, then childi is the right child of parenti.

Construct the binary tree described by descriptions and return its root.

The test cases will be generated such that the binary tree is valid.

Example 1:

Input: descriptions = [[20,15,1],[20,17,0],[50,20,1],[50,80,0],[80,19,1]]
Output: [50,20,80,15,17,19]
Explanation: The root node is the node with value 50 since it has no parent.
The resulting binary tree is shown in the diagram.

Example 2:

Input: descriptions = [[1,2,1],[2,3,0],[3,4,1]]
Output: [1,2,null,null,3,4]
Explanation: The root node is the node with value 1 since it has no parent.
The resulting binary tree is shown in the diagram.

Constraints:

• 1 <= descriptions.length <= 104
• descriptions[i].length == 3
• 1 <= parenti, childi <= 105
• 0 <= isLefti <= 1
• The binary tree described by descriptions is valid.

Solution: Hashtable + Recursion

1. Use one hashtable to track the children of each node.
2. Use another hashtable to track the parent of each node.
3. Find the root who doesn’t have parent.
4. Build the tree recursively from root.
   

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

// Author: Huahua
class Solution {
public:
  TreeNode* createBinaryTree(vector<vector<int>>& descriptions) {
    unordered_set<int> hasParent;
    unordered_map<int, pair<int, int>> children;
    for (const auto& d : descriptions) {
      hasParent.insert(d[1]);
      (d[2] ? children[d[0]].first : children[d[0]].second) = d[1];      
    }
    int root = -1;
    for (const auto& d : descriptions)
      if (!hasParent.count(d[0])) root = d[0];
    function<TreeNode*(int)> build = [&](int cur) -> TreeNode* {      
      if (!cur) return nullptr;
      return new TreeNode(cur, 
                          build(children[cur].first),
                          build(children[cur].second));
    };  
    return build(root);
  }
};

The post 花花酱 LeetCode 2196. Create Binary Tree From Descriptions appeared first on Huahua's Tech Road.

Given the root of a complete binary tree, return the number of the nodes in the tree.

According to Wikipedia, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.

Design an algorithm that runs in less than O(n) time complexity.

Example 1:

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

Example 2:

Input: root = []
Output: 0

Example 3:

Input: root = [1]
Output: 1

Constraints:

• The number of nodes in the tree is in the range [0, 5 * 104].
• 0 <= Node.val <= 5 * 104
• The tree is guaranteed to be complete.

Solution: Recursion

For each node, count the height of it’s left and right subtree by going left only.

Let L = height(left) R = height(root), if L == R, which means the left subtree is perfect.
It has (2^L – 1) nodes, +1 root, we only need to count nodes of right subtree recursively.
If L != R, L must be R + 1 since the tree is complete, which means the right subtree is perfect.
It has (2^(L-1) – 1) nodes, +1 root, we only need to count nodes of left subtree recursively.

Time complexity: T(n) = T(n/2) + O(logn) = O(logn*logn)

Space complexity: O(logn)

// Author: Huahua
class Solution {
public:
  int countNodes(TreeNode* root) {
    if (root == nullptr) return 0;
    int l = depth(root->left);
    int r = depth(root->right);
    if (l == r) 
      return (1 << l) + countNodes(root->right);
    else
      return (1 << (l - 1)) + countNodes(root->left);
  }
private:
  int depth(TreeNode* root) {
    if (root == nullptr) return 0;
    return 1 + depth(root->left);
  }
};

The post 花花酱 LeetCode 222. Count Complete Tree Nodes appeared first on Huahua's Tech Road.

Find the shortest path starting from node s and ending at node t. Generate step-by-step directions of such path as a string consisting of only the uppercase letters 'L', 'R', and 'U'. Each letter indicates a specific direction:

• 'L' means to go from a node to its left child node.
• 'R' means to go from a node to its right child node.
• 'U' means to go from a node to its parent node.

Return the step-by-step directions of the shortest path from node s to node t.

Example 1:

Input: root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6
Output: "UURL"
Explanation: The shortest path is: 3 → 1 → 5 → 2 → 6.

Example 2:

Input: root = [2,1], startValue = 2, destValue = 1
Output: "L"
Explanation: The shortest path is: 2 → 1.

Constraints:

• The number of nodes in the tree is n.
• 2 <= n <= 105
• 1 <= Node.val <= n
• All the values in the tree are unique.
• 1 <= startValue, destValue <= n
• startValue != destValue

Solution: Lowest common ancestor

It’s no hard to see that the shortest path is from the start node to the lowest common ancestor (LCA) of (start, end), then to the end node. The key is to find the LCA while finding paths from root to two nodes.

We can use recursion to find/build a path from root to a target node.
The common prefix of these two paths is the path from root to the LCA that we need to remove from the shortest path.
e.g.
root to start “LLRLR”
root to dest “LLLR”
common prefix is “LL”, after removing, it becomes:
LCA to start “RLR”
LCA to dest “LR”
Final path becomes “UUU” + “LR” = “UUULR”

The final step is to replace the L/R with U for the start path since we are moving up and then concatenate with the target path.

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

// Author: Huahua
class Solution {
public:
  string getDirections(TreeNode* root, int startValue, int destValue) {
    string startPath;
    string destPath;
    buildPath(root, startValue, startPath);
    buildPath(root, destValue, destPath);    
    // Remove common suffix (shared path from root to LCA)
    while (!startPath.empty() && !destPath.empty() 
           && startPath.back() == destPath.back()) {
      startPath.pop_back();
      destPath.pop_back();
    }
    reverse(begin(destPath), end(destPath));
    return string(startPath.size(), 'U') + destPath;
  }
private:
  bool buildPath(TreeNode* root, int t, string& path) {
    if (!root) return false;
    if (root->val == t) return true;
    if (buildPath(root->left, t, path)) {
      path.push_back('L');
      return true;
    } else if (buildPath(root->right, t, path)) {
      path.push_back('R');
      return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 2096. Step-By-Step Directions From a Binary Tree Node to Another appeared first on Huahua's Tech Road.

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Example 1:

Input: root = [1,2,3,4,5,null,7]
Output: [1,#,2,3,#,4,5,7,#]
Explanation: Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.

Example 2:

Input: root = []
Output: []

Constraints:

• The number of nodes in the tree is in the range [0, 6000].
• -100 <= Node.val <= 100

Follow-up:

• You may only use constant extra space.
• The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.

Solution -2: Group nodes into levels

Use pre-order traversal to group nodes by levels.
Connects nodes in each level.

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    vector<vector<Node*>> levels;
    dfs(root, 0, levels);
    for (auto& nodes : levels)
      for(int i = 0; i < nodes.size() - 1; ++i)
        nodes[i]->next = nodes[i+1]; 
    return root;
  }
private:
  void dfs(Node *root, int d, vector<vector<Node*>>& levels) {
    if (!root) return;
    if (levels.size() < d+1) levels.push_back({});
    levels[d].push_back(root);
    dfs(root->left, d + 1, levels);
    dfs(root->right, d + 1, levels);
  }
};

Solution -1: BFS level order traversal

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    if (!root) return root;
    queue<Node*> q{{root}};
    while (!q.empty()) {
      int size = q.size();
      Node* p = nullptr;
      while (size--) {
        Node* t = q.front(); q.pop();
        if (p) 
          p->next = t, p = p->next;
        else
          p = t;
        if (t->left) q.push(t->left);
        if (t->right) q.push(t->right);
      }
    }
    return root;
  }
};

Solution 1: BFS w/o extra space

Populating the next level while traversing current level.

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    Node* p = root;        
    while (p) {
      Node dummy;
      Node* c = &dummy;
      while (p) {
        if (p->left)
          c->next = p->left, c = c->next;
        if (p->right)
          c->next = p->right, c = c->next;
        p = p->next;
      }
      p = dummy.next;
    }
    return root;
  }
};

The post 花花酱 LeetCode 117. Populating Next Right Pointers in Each Node II appeared first on Huahua's Tech Road.

• BSTIterator(TreeNode root) Initializes an object of the BSTIterator class. The root of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.
• boolean hasNext() Returns true if there exists a number in the traversal to the right of the pointer, otherwise returns false.
• int next() Moves the pointer to the right, then returns the number at the pointer.

Notice that by initializing the pointer to a non-existent smallest number, the first call to next() will return the smallest element in the BST.

You may assume that next() calls will always be valid. That is, there will be at least a next number in the in-order traversal when next() is called.

Example 1:

Input
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
Output

[null, 3, 7, true, 9, true, 15, true, 20, false]

Explanation BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]); bSTIterator.next(); // return 3 bSTIterator.next(); // return 7 bSTIterator.hasNext(); // return True bSTIterator.next(); // return 9 bSTIterator.hasNext(); // return True bSTIterator.next(); // return 15 bSTIterator.hasNext(); // return True bSTIterator.next(); // return 20 bSTIterator.hasNext(); // return False

Constraints:

• The number of nodes in the tree is in the range [1, 105].
• 0 <= Node.val <= 106
• At most 105 calls will be made to hasNext, and next.

Follow up:

• Could you implement next() and hasNext() to run in average O(1) time and use O(h) memory, where h is the height of the tree?

Solution: In-order traversal using a stack

Use a stack to simulate in-order traversal.

Each next, we walk to the left most (smallest) node and push all the nodes along the path to the stack.

Then pop the top one t as return val, our next node to explore is the right child of t.

Time complexity: amortized O(1) for next() call.
Space complexity: O(n)

// Author: Huahua
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class BSTIterator {
public:
  BSTIterator(TreeNode* root) : root_(root) {}

  int next() {
    while (root_) {
      s_.push(root_);
      root_ = root_->left;
    }
    TreeNode* t = s_.top(); s_.pop();
    root_ = t->right;
    return t->val;
  }

  bool hasNext() {
    return (root_ || !s_.empty());
  }
private:
  TreeNode* root_;
  stack<TreeNode*> s_;
};

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator* obj = new BSTIterator(root);
 * int param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

The post 花花酱 LeetCode 173. Binary Search Tree Iterator appeared first on Huahua's Tech Road.

Example 1:

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

Example 2:

Input: root = [1,null,3]
Output: [1,3]

Example 3:

Input: root = []
Output: []

Constraints:

• The number of nodes in the tree is in the range [0, 100].
• -100 <= Node.val <= 100

Solution: Pre-order traversal

By using pre-order traversal, the right most node will be the last one to visit in each level.

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

// Author: Huahua
class Solution {
public:
  vector<int> rightSideView(TreeNode* root) {
    vector<int> ans;
    function<void(TreeNode*, int)> dfs = [&](TreeNode* root, int d) {
      if (!root) return;
      if (ans.size() < d + 1) ans.push_back(0);
      ans[d] = root->val;
      dfs(root->left, d + 1);
      dfs(root->right, d + 1);
    };
    dfs(root, 0);
    return ans;
  }
};

The post 花花酱 LeetCode 199. Binary Tree Right Side View appeared first on Huahua's Tech Road.

• The “linked list” should use the same TreeNode class where the right child pointer points to the next node in the list and the left child pointer is always null.
• The “linked list” should be in the same order as a pre-order traversal of the binary tree.

Example 1:

Input: root = [1,2,5,3,4,null,6]
Output: [1,null,2,null,3,null,4,null,5,null,6]

Example 2:

Input: root = []
Output: []

Example 3:

Input: root = [0]
Output: [0]

Constraints:

• The number of nodes in the tree is in the range [0, 2000].
• -100 <= Node.val <= 100

Follow up: Can you flatten the tree in-place (with O(1) extra space)?

Solution 1: Recursion

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

# Author: Huahua
class Solution:
  def flatten(self, root: Optional[TreeNode]) -> None:
    """
    Do not return anything, modify root in-place instead.
    """
    def solve(root: Optional[TreeNode]):
      if not root: return None, None
      if not root.left and not root.right: return root, root
      l_head = l_tail = r_head = r_tail = None
      if root.left:
        l_head, l_tail = solve(root.left)
      if root.right:
        r_head, r_tail = solve(root.right)
      root.left = None
      root.right = l_head or r_head
      if l_tail:
        l_tail.right = r_head
      return root, r_tail or l_tail
    return solve(root)[0]

Solution 2: Unfolding

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

# Author: Huahua
class Solution:
  def flatten(self, root: Optional[TreeNode]) -> None:
    while root:
      if root.left:
        prev = root.left
        while prev.right: prev = prev.right
        prev.right = root.right
        root.right = root.left
        root.left = None
      root = root.right

The post 花花酱 LeetCode 114. Flatten Binary Tree to Linked List appeared first on Huahua's Tech Road.

There are 105 genetic values, each represented by an integer in the inclusive range [1, 105]. You are given a 0-indexed integer array nums, where nums[i] is a distinct genetic value for node i.

Return an array ans of length n where ans[i] is the smallest genetic value that is missing from the subtree rooted at node i.

The subtree rooted at a node x contains node x and all of its descendant nodes.

Example 1:

Input: parents = [-1,0,0,2], nums = [1,2,3,4]
Output: [5,1,1,1]
Explanation: The answer for each subtree is calculated as follows:
- 0: The subtree contains nodes [0,1,2,3] with values [1,2,3,4]. 5 is the smallest missing value.
- 1: The subtree contains only node 1 with value 2. 1 is the smallest missing value.
- 2: The subtree contains nodes [2,3] with values [3,4]. 1 is the smallest missing value.
- 3: The subtree contains only node 3 with value 4. 1 is the smallest missing value.

Example 2:

Input: parents = [-1,0,1,0,3,3], nums = [5,4,6,2,1,3]
Output: [7,1,1,4,2,1]
Explanation: The answer for each subtree is calculated as follows:
- 0: The subtree contains nodes [0,1,2,3,4,5] with values [5,4,6,2,1,3]. 7 is the smallest missing value.
- 1: The subtree contains nodes [1,2] with values [4,6]. 1 is the smallest missing value.
- 2: The subtree contains only node 2 with value 6. 1 is the smallest missing value.
- 3: The subtree contains nodes [3,4,5] with values [2,1,3]. 4 is the smallest missing value.
- 4: The subtree contains only node 4 with value 1. 2 is the smallest missing value.
- 5: The subtree contains only node 5 with value 3. 1 is the smallest missing value.

Example 3:

Input: parents = [-1,2,3,0,2,4,1], nums = [2,3,4,5,6,7,8]
Output: [1,1,1,1,1,1,1]
Explanation: The value 1 is missing from all the subtrees.

Constraints:

• n == parents.length == nums.length
• 2 <= n <= 105
• 0 <= parents[i] <= n - 1 for i != 0
• parents[0] == -1
• parents represents a valid tree.
• 1 <= nums[i] <= 105
• Each nums[i] is distinct.

Solution: DFS on a single path

One ancestors of node with value of 1 will have missing values greater than 1. We do a dfs on the path that from node with value 1 to the root.

Time complexity: O(n + max(nums))
Space complexity: O(n + max(nums))

// Author: Huahua
class Solution {
public:
  vector<int> smallestMissingValueSubtree(vector<int>& parents, vector<int>& nums) {
    const int n = parents.size();
    vector<int> ans(n, 1);
    vector<int> seen(100002);
    vector<vector<int>> g(n);
    for (int i = 1; i < n; ++i)
      g[parents[i]].push_back(i);
    function<void(int)> dfs = [&](int u) {
      if (seen[nums[u]]++) return;
      for (int v : g[u]) dfs(v);
    };
    int u = find(begin(nums), end(nums), 1) - begin(nums);
    for (int l = 1; u < n && u != -1; u = parents[u]) {
      dfs(u);
      while (seen[l]) ++l;
      ans[u] = l;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2003. Smallest Missing Genetic Value in Each Subtree appeared first on Huahua's Tech Road.

Each node has a score. To find the score of a node, consider if the node and the edges connected to it were removed. The tree would become one or more non-empty subtrees. The size of a subtree is the number of the nodes in it. The score of the node is the product of the sizes of all those subtrees.

Return the number of nodes that have the highest score.

Example 1:

Input: parents = [-1,2,0,2,0]
Output: 3
Explanation:
- The score of node 0 is: 3 * 1 = 3
- The score of node 1 is: 4 = 4
- The score of node 2 is: 1 * 1 * 2 = 2
- The score of node 3 is: 4 = 4
- The score of node 4 is: 4 = 4
The highest score is 4, and three nodes (node 1, node 3, and node 4) have the highest score.

Example 2:

Input: parents = [-1,2,0]
Output: 2
Explanation:
- The score of node 0 is: 2 = 2
- The score of node 1 is: 2 = 2
- The score of node 2 is: 1 * 1 = 1
The highest score is 2, and two nodes (node 0 and node 1) have the highest score.

Constraints:

• n == parents.length
• 2 <= n <= 105
• parents[0] == -1
• 0 <= parents[i] <= n - 1 for i != 0
• parents represents a valid binary tree.

Solution: Recursion

Write a function that returns the element of a subtree rooted at node.

We can compute the score based on:
1. size of the subtree(s)
2. # of children

Root is a special case whose score is max(c[0], 1) * max(c[1], 1).

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

// Author: Huahua
class Solution {
public:
  int countHighestScoreNodes(vector<int>& parents) {
    const int n = parents.size();
    long high = 0;
    int ans = 0;
    vector<vector<int>> tree(n);
    for (int i = 1; i < n; ++i)
      tree[parents[i]].push_back(i);
    function<int(int)> dfs = [&](int node) -> int {      
      long c[2] = {0, 0};
      for (int i = 0; i < tree[node].size(); ++i)
        c[i] = dfs(tree[node][i]);
      long score = 0;
      if (node == 0) // case #1: root
        score = max(c[0], 1l) * max(c[1], 1l);
      else if (tree[node].size() == 0) // case #2: leaf
        score = n - 1;
      else if (tree[node].size() == 1) // case #3: one child
        score = c[0] * (n - c[0] - 1);
      else // case #4: two children
        score = c[0] * c[1] * (n - c[0] - c[1] - 1);
      if (score > high) {
        high = score;
        ans = 1;
      } else if (score == high) {
        ++ans;
      }
      return 1 + c[0] + c[1];
    };
    dfs(0);
    return ans;
  }
};

The post 花花酱 LeetCode 2049. Count Nodes With the Highest Score appeared first on Huahua's Tech Road.