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.

• 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.

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.

The tournament consists of multiple rounds (starting from round number 1). In each round, the ith player from the front of the row competes against the ith player from the end of the row, and the winner advances to the next round. When the number of players is odd for the current round, the player in the middle automatically advances to the next round.

• For example, if the row consists of players 1, 2, 4, 6, 7
  • Player 1 competes against player 7.
  • Player 2 competes against player 6.
  • Player 4 automatically advances to the next round.

After each round is over, the winners are lined back up in the row based on the original ordering assigned to them initially (ascending order).

The players numbered firstPlayer and secondPlayer are the best in the tournament. They can win against any other player before they compete against each other. If any two other players compete against each other, either of them might win, and thus you may choose the outcome of this round.

Given the integers n, firstPlayer, and secondPlayer, return an integer array containing two values, the earliest possible round number and the latest possible round number in which these two players will compete against each other, respectively.

Example 1:

Input: n = 11, firstPlayer = 2, secondPlayer = 4
Output: [3,4]
Explanation:
One possible scenario which leads to the earliest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 2, 3, 4, 5, 6, 11
Third round: 2, 3, 4
One possible scenario which leads to the latest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 1, 2, 3, 4, 5, 6
Third round: 1, 2, 4
Fourth round: 2, 4

Example 2:

Input: n = 5, firstPlayer = 1, secondPlayer = 5
Output: [1,1]
Explanation: The players numbered 1 and 5 compete in the first round.
There is no way to make them compete in any other round.

Constraints:

• 2 <= n <= 28
• 1 <= firstPlayer < secondPlayer <= n

Solution 1: Simulation using recursion

All possible paths,
Time complexity: O(n²*2ⁿ)
Space complexity: O(logn)

dfs(s, i, j, d) := let i battle with j at round d, given s (binary mask of dead players).

// Author: Huahua
class Solution {
public:
  vector<int> earliestAndLatest(int n, int a, int b) {
    vector<int> ans{INT_MAX, INT_MIN};    
    function<void(int, int, int, int)> dfs = [&](int s, int i, int j, int d) {
      while (i < j && s >> i & 1) ++i;
      while (i < j && s >> j & 1) --j;
      if (i >= j) {
        return dfs(s, 1, n, d + 1);
      } else if (i == a && j == b) {
        ans[0] = min(ans[0], d);
        ans[1] = max(ans[1], d);
      } else {
        if (i != a && i != b)
          dfs(s | (1 << i), i + 1, j - 1, d);
        if (j != a && j != b)
          dfs(s | (1 << j), i + 1, j - 1, d);
      }
    };
    dfs(0, 1, n, 1);
    return ans;
  }
};

The post 花花酱 LeetCode 1900. The Earliest and Latest Rounds Where Players Compete appeared first on Huahua's Tech Road.

• For example, "()1|1" and "(1)&()" are not valid while "1", "(((1))|(0))", and "1|(0&(1))" are valid expressions.

Return the minimum cost to change the final value of the expression.

• For example, if expression = "1|1|(0&0)&1", its value is 1|1|(0&0)&1 = 1|1|0&1 = 1|0&1 = 1&1 = 1. We want to apply operations so that the new expression evaluates to 0.

The cost of changing the final value of an expression is the number of operations performed on the expression. The types of operations are described as follows:

• Turn a '1' into a '0'.
• Turn a '0' into a '1'.
• Turn a '&' into a '|'.
• Turn a '|' into a '&'.

Note: '&' does not take precedence over '|' in the order of calculation. Evaluate parentheses first, then in left-to-right order.

Example 1:

Input: expression = "1&(0|1)"
Output: 1
Explanation: We can turn "1&(0|1)" into "1&(0&1)" by changing the '|' to a '&' using 1 operation.
The new expression evaluates to 0. 

Example 2:

<strong>Input:</strong> expression = "(0&amp;0)&amp;(0&amp;0&amp;0)"
<strong>Output:</strong> 3
<strong>Explanation:</strong> We can turn "(0<strong>&amp;0</strong>)<strong><u>&amp;</u></strong>(0&amp;0&amp;0)" into "(0<strong>|1</strong>)<strong>|</strong>(0&amp;0&amp;0)" using 3 operations.
The new expression evaluates to 1.

Example 3:

Input: expression = "(0|(1|0&1))"
Output: 1
Explanation: We can turn "(0|(1|0&1))" into "(0|(0|0&1))" using 1 operation.
The new expression evaluates to 0.

Constraints:

• 1 <= expression.length <= 105
• expression only contains '1','0','&','|','(', and ')'
• All parentheses are properly matched.
• There will be no empty parentheses (i.e: "()" is not a substring of expression).

Solution: DP, Recursion / Simulation w/ Stack

For each expression, stores the min cost to change value to 0 and 1.

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

class Solution {
public:
  int minOperationsToFlip(string expression) {
    stack<array<int, 3>> s;
    s.push({0, 0, 0});
    for (char e : expression) {
      if (e == '(')
        s.push({0, 0, 0});
      else if (e == '&' || e == '|')
        s.top()[2] = e;
      else {        
        if (isdigit(e)) s.push({e != '0', e != '1', 0});
        auto [r0, r1, _] = s.top(); s.pop();
        auto [l0, l1, op] = s.top(); s.pop();
        if (op == '&') {
          s.push({min(l0, r0),
                  min(l1 + r1, min(l1, r1) + 1),
                  0});
        } else if (op == '|') {
          s.push({min(l0 + r0, min(l0, r0) + 1),
                  min(l1, r1),
                  0});
        } else {
          s.push({r0, r1, 0});
        }
      }
    }
    return max(s.top()[0], s.top()[1]);
  }
};

The post 花花酱 LeetCode 1896. Minimum Cost to Change the Final Value of Expression appeared first on Huahua's Tech Road.

• If the current number of teams is even, each team gets paired with another team. A total of n / 2 matches are played, and n / 2 teams advance to the next round.
• If the current number of teams is odd, one team randomly advances in the tournament, and the rest gets paired. A total of (n - 1) / 2 matches are played, and (n - 1) / 2 + 1 teams advance to the next round.

Return the number of matches played in the tournament until a winner is decided.

Example 1:

Input: n = 7
Output: 6
Explanation: Details of the tournament: 
- 1st Round: Teams = 7, Matches = 3, and 4 teams advance.
- 2nd Round: Teams = 4, Matches = 2, and 2 teams advance.
- 3rd Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
Total number of matches = 3 + 2 + 1 = 6.

Example 2:

Input: n = 14
Output: 13
Explanation: Details of the tournament:
- 1st Round: Teams = 14, Matches = 7, and 7 teams advance.
- 2nd Round: Teams = 7, Matches = 3, and 4 teams advance.
- 3rd Round: Teams = 4, Matches = 2, and 2 teams advance.
- 4th Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
Total number of matches = 7 + 3 + 2 + 1 = 13.

Constraints:

• 1 <= n <= 200

Solution: Simulation / Recursion

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

// Ver 1
class Solution {
public:
  int numberOfMatches(int n) {
    int ans = 0;
    while (n > 1) {
      ans += n / 2 + (n & 1);
      n /= 2;
    }
    return ans;
  }
};
// Ver 2
class Solution {
public:
  int numberOfMatches(int n) {
    return n > 1 ? n / 2 + (n & 1) + numberOfMatches(n / 2) : 0;
  }
};

The post 花花酱 LeetCode 1688. Count of Matches in Tournament appeared first on Huahua's Tech Road.

The kingdom has a well-defined order of inheritance that consists of the king as the first member. Let’s define the recursive function Successor(x, curOrder), which given a person x and the inheritance order so far, returns who should be the next person after x in the order of inheritance.

Successor(x, curOrder):
    if x has no children or all of x's children are in curOrder:
        if x is the king return null
        else return Successor(x's parent, curOrder)
    else return x's oldest child who's not in curOrder

For example, assume we have a kingdom that consists of the king, his children Alice and Bob (Alice is older than Bob), and finally Alice’s son Jack.

1. In the beginning, curOrder will be ["king"].
2. Calling Successor(king, curOrder) will return Alice, so we append to curOrder to get ["king", "Alice"].
3. Calling Successor(Alice, curOrder) will return Jack, so we append to curOrder to get ["king", "Alice", "Jack"].
4. Calling Successor(Jack, curOrder) will return Bob, so we append to curOrder to get ["king", "Alice", "Jack", "Bob"].
5. Calling Successor(Bob, curOrder) will return null. Thus the order of inheritance will be ["king", "Alice", "Jack", "Bob"].

Using the above function, we can always obtain a unique order of inheritance.

Implement the ThroneInheritance class:

• ThroneInheritance(string kingName) Initializes an object of the ThroneInheritance class. The name of the king is given as part of the constructor.
• void birth(string parentName, string childName) Indicates that parentName gave birth to childName.
• void death(string name) Indicates the death of name. The death of the person doesn’t affect the Successor function nor the current inheritance order. You can treat it as just marking the person as dead.
• string[] getInheritanceOrder() Returns a list representing the current order of inheritance excluding dead people.

Example 1:

Input
["ThroneInheritance", "birth", "birth", "birth", "birth", "birth", "birth", "getInheritanceOrder", "death", "getInheritanceOrder"]
[["king"], ["king", "andy"], ["king", "bob"], ["king", "catherine"], ["andy", "matthew"], ["bob", "alex"], ["bob", "asha"], [null], ["bob"], [null]]
Output
[null, null, null, null, null, null, null, ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"], null, ["king", "andy", "matthew", "alex", "asha", "catherine"]]
Explanation
ThroneInheritance t= new ThroneInheritance("king"); // order: king
t.birth("king", "andy"); // order: king > andy
t.birth("king", "bob"); // order: king > andy > bob
t.birth("king", "catherine"); // order: king > andy > bob > catherine
t.birth("andy", "matthew"); // order: king > andy > matthew > bob > catherine
t.birth("bob", "alex"); // order: king > andy > matthew > bob > alex > catherine
t.birth("bob", "asha"); // order: king > andy > matthew > bob > alex > asha > catherine
t.getInheritanceOrder(); // return ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"]
t.death("bob"); // order: king > andy > matthew > bob > alex > asha > catherine
t.getInheritanceOrder(); // return ["king", "andy", "matthew", "alex", "asha", "catherine"]

Constraints:

• 1 <= kingName.length, parentName.length, childName.length, name.length <= 15
• kingName, parentName, childName, and name consist of lowercase English letters only.
• All arguments childName and kingName are distinct.
• All name arguments of death will be passed to either the constructor or as childName to birth first.
• For each call to birth(parentName, childName), it is guaranteed that parentName is alive.
• At most 105 calls will be made to birth and death.
• At most 10 calls will be made to getInheritanceOrder.

Solution: HashTable + DFS

Record :
1. mapping from parent to children (ordered)
2. who has dead

Time complexity: getInheritanceOrder O(n), other O(1)
Space complexity: O(n)

// Author: Huahua
class ThroneInheritance {
public:
  ThroneInheritance(string kingName): king_(kingName) {
    m_[kingName] = {};
  }

  void birth(string parentName, string childName) {
    m_[parentName].push_back(childName);
  }

  void death(string name) {
    dead_.insert(name);
  }

  vector<string> getInheritanceOrder() {
    vector<string> ans;
    function<void(const string&)> dfs = [&](const string& name) {
      if (!dead_.count(name)) ans.push_back(name);
      for (const string& child: m_[name]) dfs(child);
    };
    dfs(king_);
    return ans;
  }
private:  
  string king_;  
  unordered_map<string, vector<string>> m_; // parent -> list[children]
  unordered_set<string> dead_;
};

# Author: Huahua
class ThroneInheritance:
  def __init__(self, kingName: str):
    self.kingName = kingName
    self.family = defaultdict(list)    
    self.dead = set()

  def birth(self, parentName: str, childName: str) -> None:
    self.family[parentName].append(childName)

  def death(self, name: str) -> None:
    self.dead.add(name)

  def getInheritanceOrder(self) -> List[str]:
    order = []
    def dfs(name: str):
      if name not in self.dead: order.append(name)
      for child in self.family[name]: dfs(child)
    dfs(self.kingName)
    return order

The post 花花酱 LeetCode 1600. Throne Inheritance appeared first on Huahua's Tech Road.

For example, given nums = [2,1,3], we will have 2 as the root, 1 as a left child, and 3 as a right child. The array [2,3,1] also yields the same BST but [3,2,1] yields a different BST.

Return the number of ways to reorder nums such that the BST formed is identical to the original BST formed from nums.

Since the answer may be very large, return it modulo 10^9 + 7.

Example 1:

Input: nums = [2,1,3]
Output: 1
Explanation: We can reorder nums to be [2,3,1] which will yield the same BST. There are no other ways to reorder nums which will yield the same BST.

Example 2:

Input: nums = [3,4,5,1,2]
Output: 5
Explanation: The following 5 arrays will yield the same BST: 
[3,1,2,4,5]
[3,1,4,2,5]
[3,1,4,5,2]
[3,4,1,2,5]
[3,4,1,5,2]

Example 3:

Input: nums = [1,2,3]
Output: 0
Explanation: There are no other orderings of nums that will yield the same BST.

Example 4:

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

Example 5:

Input: nums = [9,4,2,1,3,6,5,7,8,14,11,10,12,13,16,15,17,18]
Output: 216212978
Explanation: The number of ways to reorder nums to get the same BST is 3216212999. Taking this number modulo 10^9 + 7 gives 216212978.

Constraints:

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= nums.length
• All integers in nums are distinct.

Solution: Recursion + Combinatorics

For a given root (first element of the array), we can split the array into left children (nums[i] < nums[0]) and right children (nums[i] > nums[0]). Assuming there are l nodes for the left and r nodes for the right. We have C(l + r, l) different ways to insert l elements into a (l + r) sized array. Within node l / r nodes, we have ways(left) / ways(right) different ways to re-arrange those nodes. So the total # of ways is:
C(l + r, l) * ways(l) * ways(r)
Don’t forget to minus one for the final answer.

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

class Solution {
public:
  int numOfWays(vector<int>& nums) {
    const int n = nums.size();
    const int kMod = 1e9 + 7;
    vector<vector<int>> cnk(n + 1, vector<int>(n + 1, 1));    
    for (int i = 1; i <= n; ++i)      
      for (int j = 1; j < i; ++j)
        cnk[i][j] = (cnk[i - 1][j] + cnk[i - 1][j - 1]) % kMod;    
    function<int(vector<int>)> trees = [&](const vector<int>& nums) {
      const int n = nums.size();
      if (n <= 2) return 1;
      vector<int> left;
      vector<int> right;
      for (int i = 1; i < nums.size(); ++i)
        if (nums[i] < nums[0]) left.push_back(nums[i]);
        else right.push_back(nums[i]);
      long ans = cnk[n - 1][left.size()];
      ans = (ans * trees(left)) % kMod;      
      ans = (ans * trees(right)) % kMod;      
      return static_cast<int>(ans);
    };
    return trees(nums) - 1;
  } 
};

class Solution:
  def numOfWays(self, nums: List[int]) -> int:
    def ways(nums):
      if len(nums) <= 2: return 1
      l = [x for x in nums if x < nums[0]]
      r = [x for x in nums if x > nums[0]]
      return comb(len(l) + len(r), len(l)) * ways(l) * ways(r)
    return (ways(nums) - 1) % (10**9 + 7)

The post 花花酱 LeetCode 1569. Number of Ways to Reorder Array to Get Same BST appeared first on Huahua's Tech Road.

The edges array is given on the form edges[i] = [ai, bi], which means there is an edge between nodes ai and bi in the tree.

Return an array of size n where ans[i] is the number of nodes in the subtree of the ith node which have the same label as node i.

A subtree of a tree T is the tree consisting of a node in T and all of its descendant nodes.

Example 1:

Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = "abaedcd"
Output: [2,1,1,1,1,1,1]
Explanation: Node 0 has label 'a' and its sub-tree has node 2 with label 'a' as well, thus the answer is 2. Notice that any node is part of its sub-tree.
Node 1 has a label 'b'. The sub-tree of node 1 contains nodes 1,4 and 5, as nodes 4 and 5 have different labels than node 1, the answer is just 1 (the node itself).

Example 2:

Input: n = 4, edges = [[0,1],[1,2],[0,3]], labels = "bbbb"
Output: [4,2,1,1]
Explanation: The sub-tree of node 2 contains only node 2, so the answer is 1.
The sub-tree of node 3 contains only node 3, so the answer is 1.
The sub-tree of node 1 contains nodes 1 and 2, both have label 'b', thus the answer is 2.
The sub-tree of node 0 contains nodes 0, 1, 2 and 3, all with label 'b', thus the answer is 4.

Example 3:

Input: n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = "aabab"
Output: [3,2,1,1,1]

Example 4:

<strong>Input:</strong> n = 6, edges = [[0,1],[0,2],[1,3],[3,4],[4,5]], labels = "cbabaa"
<strong>Output:</strong> [1,2,1,1,2,1]

Example 5:

Input: n = 7, edges = [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]], labels = "aaabaaa"
Output: [6,5,4,1,3,2,1]

Constraints:

• 1 <= n <= 10^5
• edges.length == n - 1
• edges[i].length == 2
• 0 <= ai, bi < n
• ai != bi
• labels.length == n
• labels is consisting of only of lower-case English letters.

Solution: Post order traversal + hashtable

For each label, record the count. When visiting a node, we first record the current count of its label as before, and traverse its children, when done, increment the current count, ans[i] = current – before.

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

// Author: Huahua
class Solution {
public:
  vector<int> countSubTrees(int n, vector<vector<int>>& edges, 
                            string_view labels) {
    vector<vector<int>> g(n);    
    for (const auto& e : edges) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }
    vector<int> seen(n);
    vector<int> count(26);
    vector<int> ans(n);
    function<void(int)> postOrder = [&](int i) {
      if (seen[i]++) return;
      int before = count[labels[i] - 'a'];
      for (int j : g[i]) postOrder(j);        
      ans[i] = ++count[labels[i] - 'a'] - before;
    };
    postOrder(0);
    return ans;
  }
};

// Author: Huahua
class Solution {
  private List<List<Integer>> g;
  private String labels;
  private int[] ans;
  private int[] seen;
  private int[] count;
  
  public int[] countSubTrees(int n, int[][] edges, String labels) {
    this.g = new ArrayList<List<Integer>>(n);
    this.labels = labels; 
    for (int i = 0; i < n; ++i)
      this.g.add(new ArrayList<Integer>());
    for (int[] e : edges) {
      this.g.get(e[0]).add(e[1]);
      this.g.get(e[1]).add(e[0]);
    }
    this.ans = new int[n];
    this.seen = new int[n];
    this.count = new int[26];
    this.postOrder(0);
    return ans;
  }
  
  private void postOrder(int i) {
    if (this.seen[i]++ > 0) return;
    int before = this.count[this.labels.charAt(i) - 'a'];
    for (int j : this.g.get(i)) this.postOrder(j);
    this.ans[i] = ++this.count[this.labels.charAt(i) - 'a'] - before;    
  }
}

# Author: Huahua
class Solution:
  def countSubTrees(self, n: int, edges: List[List[int]], 
                    labels: str) -> List[int]:
    g = [[] for _ in range(n)]
    for u, v in edges:
      g[u].append(v)
      g[v].append(u)
    seen = [False] * n
    count = [0] * 26
    ans = [0] * n
    def postOrder(i):
      if seen[i]: return
      seen[i] = True
      before = count[ord(labels[i]) - ord('a')]
      for j in g[i]: postOrder(j)
      count[ord(labels[i]) - ord('a')] += 1
      ans[i] = count[ord(labels[i]) - ord('a')] - before
    postOrder(0)
    return ans

The post 花花酱 LeetCode 1519. Number of Nodes in the Sub-Tree With the Same Label appeared first on Huahua's Tech Road.

Return the number of good nodes in the binary tree.

Example 1:

Input: root = [3,1,4,3,null,1,5]
Output: 4
Explanation: Nodes in blue are good.
Root Node (3) is always a good node.
Node 4 -> (3,4) is the maximum value in the path starting from the root.
Node 5 -> (3,4,5) is the maximum value in the path
Node 3 -> (3,1,3) is the maximum value in the path.

Example 2:

Input: root = [3,3,null,4,2]
Output: 3
Explanation: Node 2 -> (3, 3, 2) is not good, because "3" is higher than it.

Example 3:

Input: root = [1]
Output: 1
Explanation: Root is considered as good.

Constraints:

• The number of nodes in the binary tree is in the range [1, 10^5].
• Each node’s value is between [-10^4, 10^4].

Solution: Recursion

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

// Author: Huahua
class Solution {
public:
  int goodNodes(TreeNode* root, int max_val = INT_MIN) {
    if (!root) return 0;    
    return goodNodes(root->left, max(max_val, root->val))
           + goodNodes(root->right, max(max_val, root->val))
           + (root->val >= max_val ? 1 : 0);
  }
};

The post 花花酱 LeetCode 1448. Count Good Nodes in Binary Tree appeared first on Huahua's Tech Road.

The Fibonacci numbers are defined as:

• F₁ = 1
• F₂ = 1
• F_n = F_n-1 + F_n-2 , for n > 2.

It is guaranteed that for the given constraints we can always find such fibonacci numbers that sum k.

Example 1:

Input: k = 7
Output: 2 
Explanation: The Fibonacci numbers are: 1, 1, 2, 3, 5, 8, 13, ... 
For k = 7 we can use 2 + 5 = 7.

Example 2:

Input: k = 10
Output: 2 
Explanation: For k = 10 we can use 2 + 8 = 10.

Example 3:

Input: k = 19
Output: 3 
Explanation: For k = 19 we can use 1 + 5 + 13 = 19.

Constraints:

• 1 <= k <= 10^9

Solution: Greedy

Find the largest fibonacci numbers x that x <= k, ans = 1 + find(k – x)

Time complexity: O(logk^2) -> O(logk)
Space complexity: O(logk) -> O(1)

Recursive

// Author: Huahua
class Solution {
public:
  int findMinFibonacciNumbers(int k) {
    if (k == 0) return 0;
    int f1 = 1;
    int f2 = 1;    
    while (f2 <= k) {
      swap(f1, f2);
      f2 += f1;
    }    
    return 1 + findMinFibonacciNumbers(k - f1);
  }
};

Iterative

// Author: Huahua
class Solution {
public:
  int findMinFibonacciNumbers(int k) {
    int f1 = 1;
    int f2 = 1;
    int ans = 1;
    while (f2 <= k) {
      swap(f1, f2);
      f2 += f1;
    }    
    k -= f1;
    while (k) {
      if (k >= f1) {
        k -= f1;
        ans += 1;
      }
      f2 -= f1;
      swap(f1, f2);      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1414. Find the Minimum Number of Fibonacci Numbers Whose Sum Is K appeared first on Huahua's Tech Road.

The cloned tree is a copy of the original tree.

Return a reference to the same node in the cloned tree.

Note that you are not allowed to change any of the two trees or the target node and the answer must be a reference to a node in the cloned tree.

Follow up: Solve the problem if repeated values on the tree are allowed.

Example 1:

Input: tree = [7,4,3,null,null,6,19], target = 3
Output: 3
Explanation: In all examples the original and cloned trees are shown. The target node is a green node from the original tree. The answer is the yellow node from the cloned tree.

Example 2:

Input: tree = [7], target =  7
Output: 7

Example 3:

Input: tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
Output: 4

Example 4:

Input: tree = [1,2,3,4,5,6,7,8,9,10], target = 5
Output: 5

Example 5:

Input: tree = [1,2,null,3], target = 2
Output: 2

Constraints:

• The number of nodes in the tree is in the range [1, 10^4].
• The values of the nodes of the tree are unique.
• target node is a node from the original tree and is not null.

Solution: Recursion

Traverse both trees in the same order, if original == target, return cloned.

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

// Author: Huahua
class Solution {
public:
  TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
    if (!original) return nullptr;
    if (original == target) return cloned;
    auto l = getTargetCopy(original->left, cloned->left, target);
    auto r = getTargetCopy(original->right, cloned->right, target);
    return l ? l : r;
  }
};

# Author: Huahua
class Solution:
  def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
    if not original: return None
    if original == target: return cloned
    return self.getTargetCopy(original.left, cloned.left, target) or \
           self.getTargetCopy(original.right, cloned.right, target)

The post 花花酱 LeetCode 1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree appeared first on Huahua's Tech Road.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

Example 1:

Input: "1 + 1"
Output: 2

Example 2:

Input: " 2-1 + 2 "
Output: 3

Example 3:

Input: "(1+(4+5+2)-3)+(6+8)"
Output: 23

Note:

• You may assume that the given expression is always valid.
• Do not use the eval built-in library function.

Solution: Recursion

Make a recursive call when there is an open parenthesis and return if there is close parenthesis.

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

// Author: Huahua
class Solution {
public:
  int calculate(string s) {    
    function<int(int&)> eval = [&](int& pos) {
      int ret = 0;
      int sign = 1;
      int val = 0;
      while (pos < s.size()) {
        const char ch = s[pos];
        if (isdigit(ch)) {
          val = val * 10 + (s[pos++] - '0');
        } else if (ch == '+' || ch == '-') {
          ret += sign * val;
          val = 0;
          sign = ch == '+' ? 1 : -1;
          ++pos;
        } else if (ch == '(') {
          val = eval(++pos);
        } else if (ch == ')') {          
          ++pos;
          break;
        } else {
          ++pos;
        }
      }
      return ret += sign * val;
    };
    int pos = 0;
    return eval(pos);
  }
};

# Author: Huahua
class Solution:
  def calculate(self, s: str) -> int:
    self.pos = 0    
    def eval():
      val = 0
      sign = 1
      ret = 0
      while self.pos < len(s):
        ch = s[self.pos]
        if ch == ' ':
          self.pos += 1
        elif ch == '(':
          self.pos += 1
          val = eval()
        elif ch == ')':
          self.pos += 1
          ret += sign * val
          return ret
        elif ch == '+' or ch == '-':
          ret += sign * val
          val = 0
          sign = 1 if ch == '+' else -1
          self.pos += 1
        else:
          val = val * 10 + (ord(ch) - ord('0'))
          self.pos += 1
      ret += val * sign
      return ret
    return eval()

The post 花花酱 LeetCode 224. Basic Calculator appeared first on Huahua's Tech Road.