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 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];
  }
};

There is a meeting for the representatives of each city. The meeting is in the capital city.

There is a car in each city. You are given an integer seats that indicates the number of seats in each car.

A representative can use the car in their city to travel or change the car and ride with another representative. The cost of traveling between two cities is one liter of fuel.

Return the minimum number of liters of fuel to reach the capital city.

Example 1:

Input: roads = [[0,1],[0,2],[0,3]], seats = 5
Output: 3
Explanation: 
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative2 goes directly to the capital with 1 liter of fuel.
- Representative3 goes directly to the capital with 1 liter of fuel.
It costs 3 liters of fuel at minimum. 
It can be proven that 3 is the minimum number of liters of fuel needed.

Example 2:

Input: roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
Output: 7
Explanation: 
- Representative2 goes directly to city 3 with 1 liter of fuel.
- Representative2 and representative3 go together to city 1 with 1 liter of fuel.
- Representative2 and representative3 go together to the capital with 1 liter of fuel.
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative5 goes directly to the capital with 1 liter of fuel.
- Representative6 goes directly to city 4 with 1 liter of fuel.
- Representative4 and representative6 go together to the capital with 1 liter of fuel.
It costs 7 liters of fuel at minimum. 
It can be proven that 7 is the minimum number of liters of fuel needed.

Example 3:

Input: roads = [], seats = 1
Output: 0
Explanation: No representatives need to travel to the capital city.

Constraints:

• 1 <= n <= 105
• roads.length == n - 1
• roads[i].length == 2
• 0 <= ai, bi < n
• ai != bi
• roads represents a valid tree.
• 1 <= seats <= 105

Solution: Greedy + DFS

To reach the minimum cost, we must share cars if possible, say X reps from children nodes to an intermediate node u on the way towards capital 0. Then they all changes cars at node u, and we need (X + 1) // seats cars/fuel from u to 0.

We use DFS to count # of reps at each node u while accumulating the total cost.

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

// Author: Huahua
class Solution {
public:
  long long minimumFuelCost(vector<vector<int>>& roads, int seats) {
    long long ans = 0;
    vector<vector<int>> g(roads.size() + 1);
    for (const vector<int>& r : roads) {
      g[r[0]].push_back(r[1]);
      g[r[1]].push_back(r[0]);
    }
    // Returns total # of children of u.
    function<int(int, int)> dfs = [&](int u, int p, int rep = 1) {      
      for (int v : g[u])
        if (v != p) rep += dfs(v, u);
      if (u) ans += (rep + seats - 1) / seats;
      return rep;
    };
    dfs(0, -1);
    return ans;
  }
};

You are given the root of a binary search tree and an array queries of size n consisting of positive integers.

Find a 2D array answer of size n where answer[i] = [mini, maxi]:

• mini is the largest value in the tree that is smaller than or equal to queries[i]. If a such value does not exist, add -1 instead.
• maxi is the smallest value in the tree that is greater than or equal to queries[i]. If a such value does not exist, add -1 instead.

Return the array answer.

Example 1:

Input: root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]
Output: [[2,2],[4,6],[15,-1]]
Explanation: We answer the queries in the following way:
- The largest number that is smaller or equal than 2 in the tree is 2, and the smallest number that is greater or equal than 2 is still 2. So the answer for the first query is [2,2].
- The largest number that is smaller or equal than 5 in the tree is 4, and the smallest number that is greater or equal than 5 is 6. So the answer for the second query is [4,6].
- The largest number that is smaller or equal than 16 in the tree is 15, and the smallest number that is greater or equal than 16 does not exist. So the answer for the third query is [15,-1].

Example 2:

Input: root = [4,null,9], queries = [3]
Output: [[-1,4]]
Explanation: The largest number that is smaller or equal to 3 in the tree does not exist, and the smallest number that is greater or equal to 3 is 4. So the answer for the query is [-1,4].

Constraints:

• The number of nodes in the tree is in the range [2, 105].
• 1 <= Node.val <= 106
• n == queries.length
• 1 <= n <= 105
• 1 <= queries[i] <= 106

Solution: Convert to sorted array

Since we don’t know whether the tree is balanced or not, the safest and easiest way is to convert the tree into a sorted array using inorder traversal. Or just any traversal and sort the array later on.

Once we have a sorted array, we can use lower_bound / upper_bound to query.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};
      auto lit = upper_bound(begin(vals), end(vals), q);
      if (lit != begin(vals))
        cur[0] = *(prev(lit));
      auto rit = lower_bound(begin(vals), end(vals), q);
      if (rit != end(vals))
        cur[1] = *rit;      
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

One binary search per query.

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      if (vals.empty() || root->val > vals.back()) vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};      
      auto it = lower_bound(begin(vals), end(vals), q);
      if (it != end(vals) && *it == q)
        cur[0] = cur[1] = q;
      else {
        if (it != begin(vals)) cur[0] = *prev(it);
        if (it != end(vals)) cur[1] = *it;        
      }
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

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));
  }
};

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;
  }
};

• 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);
  }
};

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);
  }
};

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;
  }
};

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;
  }
};

• 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();
 */

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 “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

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example 1:

Input: head = [-10,-3,0,5,9]
Output: [0,-3,9,-10,null,5]
Explanation: One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.

Example 2:

Input: head = []
Output: []

Example 3:

Input: head = [0]
Output: [0]

Example 4:

Input: head = [1,3]
Output: [3,1]

Constraints:

• The number of nodes in head is in the range [0, 2 * 104].
• -105 <= Node.val <= 105

Solution 1: Recursion w/ Fast + Slow Pointers

For each sublist, use fast/slow pointers to find the mid and build the tree.

Time complexity: O(nlogn)
Space complexity: O(logn)

// Author: Huahua
class Solution {
public:
  TreeNode *sortedListToBST(ListNode *head) {
    function<TreeNode*(ListNode*, ListNode*)> build 
      = [&](ListNode* head, ListNode* tail) -> TreeNode* {
      if (!head || head == tail) return nullptr;
      ListNode *fast = head, *slow = head;
      while (fast != tail && fast->next != tail) {
        slow = slow->next;
        fast = fast->next->next;
      }
      TreeNode *root = new TreeNode(slow->val);
      root->left = build(head, slow);
      root->right = build(slow->next, tail);
      return root;
    };
    return build(head, nullptr);
  }
};

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;
  }
};