Given a string n that represents a positive decimal integer, return the minimum number of positive deci-binary numbers needed so that they sum up to n.

Example 1:

Input: n = "32"
Output: 3
Explanation: 10 + 11 + 11 = 32

Example 2:

Input: n = "82734"
Output: 8

Example 3:

Input: n = "27346209830709182346"
Output: 9

Constraints:

• 1 <= n.length <= 105
• n consists of only digits.
• n does not contain any leading zeros and represents a positive integer.

Solution: Return the max digit

Proof: For a given string, we find the maximum number m, we create m binary strings.
for each one, check each digit, if it’s greater than 0, we mark 1 at that position and decrease the digit by 1.

e.g. 21534
max is 5, we need five binary strings.
1. 11111: 21534 -> 10423
2. 10111: 10423 -> 00312
3: 00111: 00312 -> 00201
4: 00101: 00201 -> 00100
5: 00100: 00100 -> 00000

We can ignore the leading zeros.

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

// Author: Huahua
class Solution {
public:
  int minPartitions(string n) {
    return *max_element(begin(n), end(n)) - '0';
  }
};

The post 花花酱 LeetCode 1689. Partitioning Into Minimum Number Of Deci-Binary Numbers appeared first on Huahua's Tech Road.

Build and return an integer array result with the same length as nums such that result[i] is equal to the summation of absolute differences between nums[i] and all the other elements in the array.

In other words, result[i] is equal to sum(|nums[i]-nums[j]|) where 0 <= j < nums.length and j != i (0-indexed).

Example 1:

Input: nums = [2,3,5]
Output: [4,3,5]
Explanation: Assuming the arrays are 0-indexed, then
result[0] = |2-2| + |2-3| + |2-5| = 0 + 1 + 3 = 4,
result[1] = |3-2| + |3-3| + |3-5| = 1 + 0 + 2 = 3,
result[2] = |5-2| + |5-3| + |5-5| = 3 + 2 + 0 = 5.

Example 2:

Input: nums = [1,4,6,8,10]
Output: [24,15,13,15,21]

Constraints:

• 2 <= nums.length <= 105
• 1 <= nums[i] <= nums[i + 1] <= 104

Solution: Prefix Sum

Let s[i] denote sum(num[i] – num[j]) 0 <= j <= i
s[i] = s[i – 1] + (num[i] – num[i – 1]) * i
Let l[i] denote sum(nums[j] – nums[i]) i <= j < n
l[i] = l[i + 1] + (nums[i + 1] – num[i]) * (n – i – 1)
ans[i] = s[i] + l[i]

e.g. 1, 3, 7, 9
s[0] = 0
s[1] = 0 + (3 – 1) * 1 = 2
s[2] = 2 + (7 – 3) * 2 = 10
s[3] = 10 + (9 – 7) * 3 = 16
l[3] = 0
l[2] = 0 + (9 – 7) * 1 = 2
l[1] = 2 + (7 – 3) * 2 = 10
l[0] = 10 + (3 – 1) * 3 = 16

ans = [16, 12, 12, 16]

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

// Author: Huahua
class Solution {
public:
  vector<int> getSumAbsoluteDifferences(vector<int>& nums) {
    const int n = nums.size();
    vector<int> ans(n);    
    for (int i = 1, sum = 0; i < n; ++i)
      ans[i] += (sum += (nums[i] - nums[i - 1]) * i);
    for (int i = n - 2, sum = 0; i >= 0; --i)
      ans[i] += (sum += (nums[i + 1] - nums[i]) * (n - i - 1));
    return ans;
  }
};

The post 花花酱 LeetCode 1685. Sum of Absolute Differences in a Sorted Array appeared first on Huahua's Tech Road.

You are given a string keysPressed of length n, where keysPressed[i] was the ith key pressed in the testing sequence, and a sorted list releaseTimes, where releaseTimes[i] was the time the ith key was released. Both arrays are 0-indexed. The 0th key was pressed at the time 0, and every subsequent key was pressed at the exact time the previous key was released.

The tester wants to know the key of the keypress that had the longest duration. The ithkeypress had a duration of releaseTimes[i] - releaseTimes[i - 1], and the 0th keypress had a duration of releaseTimes[0].

Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key may not have had the same duration.

Return the key of the keypress that had the longest duration. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.

Example 1:

Input: releaseTimes = [9,29,49,50], keysPressed = "cbcd"
Output: "c"
Explanation: The keypresses were as follows:
Keypress for 'c' had a duration of 9 (pressed at time 0 and released at time 9).
Keypress for 'b' had a duration of 29 - 9 = 20 (pressed at time 9 right after the release of the previous character and released at time 29).
Keypress for 'c' had a duration of 49 - 29 = 20 (pressed at time 29 right after the release of the previous character and released at time 49).
Keypress for 'd' had a duration of 50 - 49 = 1 (pressed at time 49 right after the release of the previous character and released at time 50).
The longest of these was the keypress for 'b' and the second keypress for 'c', both with duration 20.
'c' is lexicographically larger than 'b', so the answer is 'c'.

Example 2:

Input: releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
Output: "a"
Explanation: The keypresses were as follows:
Keypress for 's' had a duration of 12.
Keypress for 'p' had a duration of 23 - 12 = 11.
Keypress for 'u' had a duration of 36 - 23 = 13.
Keypress for 'd' had a duration of 46 - 36 = 10.
Keypress for 'a' had a duration of 62 - 46 = 16.
The longest of these was the keypress for 'a' with duration 16.

Constraints:

• releaseTimes.length == n
• keysPressed.length == n
• 2 <= n <= 1000
• 0 <= releaseTimes[i] <= 109
• releaseTimes[i] < releaseTimes[i+1]
• keysPressed contains only lowercase English letters.

Solution: Straightforward

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

class Solution {
public:
  char slowestKey(vector& releaseTimes, string keysPressed) {
    int l = releaseTimes[0];
    char ans = keysPressed[0];
    
    for (int i = 1; i < releaseTimes.size(); ++i) {
      int t = releaseTimes[i] - releaseTimes[i - 1];
      if (t > l) { 
        ans = keysPressed[i]; 
        l = t;
      } else if (t == l) {
        ans = max(ans, keysPressed[i]);      
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1629. Slowest Key appeared first on Huahua's Tech Road.

In each iteration, you calculate the step by step sum of startValue plus elements in nums (from left to right).

Return the minimum positive value of startValue such that the step by step sum is never less than 1.

Example 1:

Input: nums = [-3,2,-3,4,2]
Output: 5
Explanation: If you choose startValue = 4, in the third iteration your step by step sum is less than 1.
                step by step sum
                startValue = 4 | startValue = 5 | nums
                  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
                  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
                  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
                  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
                  (4 +2 ) = 6  | (5 +2 ) = 7    |   2

Example 2:

Input: nums = [1,2]
Output: 1
Explanation: Minimum start value should be positive. 

Example 3:

Input: nums = [1,-2,-3]
Output: 5

Constraints:

• 1 <= nums.length <= 100
• -100 <= nums[i] <= 100

Solution: Prefix sum

Find the minimum prefix sum, ans = – min(prefix_sum, 0) + 1

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

// Author: Huahua
class Solution {
public:
  int minStartValue(vector<int>& nums) {
    int min_sum = 0;
    int sum = 0;
    for (int num : nums) {
      sum += num;
      min_sum = min(min_sum, sum);
    }
    return -min_sum + 1;
  }
};

The post 花花酱 LeetCode 1413. Minimum Value to Get Positive Step by Step Sum appeared first on Huahua's Tech Road.

• If the current number is even, you have to divide it by 2.
• If the current number is odd, you have to add 1 to it.

It’s guaranteed that you can always reach to one for all testcases.

Example 1:

Input: s = "1101"
Output: 6
Explanation: "1101" corressponds to number 13 in their decimal representation.
Step 1) 13 is odd, add 1 and obtain 14. 
Step 2) 14 is even, divide by 2 and obtain 7.
Step 3) 7 is odd, add 1 and obtain 8.
Step 4) 8 is even, divide by 2 and obtain 4.  
Step 5) 4 is even, divide by 2 and obtain 2. 
Step 6) 2 is even, divide by 2 and obtain 1.  

Example 2:

Input: s = "10"
Output: 1
Explanation: "10" corressponds to number 2 in their decimal representation.
Step 1) 2 is even, divide by 2 and obtain 1.  

Example 3:

Input: s = "1"
Output: 0

Constraints:

• 1 <= s.length <= 500
• s consists of characters ‘0’ or ‘1’
• s[0] == '1'

Solution: Simulation

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

// Author: Huahua
class Solution {
public:
  int numSteps(string s) {
    int ans = 0;
    int carry = 0;
    // The highest bit must be 1, 
    // process to the 2nd highest bit
    for (int i = s.length() - 1; i > 0; --i) {
      if (s[i] - '0' + carry == 1) {
        ans += 2; // odd: +1, even: / 2
        carry = 1; // always has a carry
      } else {
        ans += 1; // even: / 2
        // carray remains e.g. 1 + 1 = 10, or 0 + 0 = 00
      }
    }
    // If there is a carry, then it's even, one more step.
    return ans + carry;
  }
};

# Author: Huahua
class Solution:
  def numSteps(self, s: str) -> int:
    ans, carry = 0, 0
    for i in range(1, len(s)):
      if ord(s[-i]) - ord('0') + carry == 1:
        ans += 2
        carry = 1
      else:
        ans += 1
    return ans + carry

The post 花花酱 LeetCode 1404. Number of Steps to Reduce a Number in Binary Representation to One appeared first on Huahua's Tech Road.

At moment k (for k from 0 to n - 1), we turn on the light[k] bulb. A bulb change color to blue only if it is on and all the previous bulbs (to the left) are turned on too.

Return the number of moments in which all turned on bulbs are blue.

Example 1:

Input: light = [2,1,3,5,4]
Output: 3
Explanation: All bulbs turned on, are blue at the moment 1, 2 and 4.

Example 2:

Input: light = [3,2,4,1,5]
Output: 2
Explanation: All bulbs turned on, are blue at the moment 3, and 4 (index-0).

Example 3:

Input: light = [4,1,2,3]
Output: 1
Explanation: All bulbs turned on, are blue at the moment 3 (index-0).
Bulb 4th changes to blue at the moment 3.

Example 4:

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

Example 5:

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

Constraints:

• n == light.length
• 1 <= n <= 5 * 10^4
• light is a permutation of  [1, 2, ..., n]

Solution

Track the right most light l_k, all turned-on lights are blue if and only if the right most one is k, and there are exact k lights on right now.

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

// Author: Huahua
class Solution {
public:
  int numTimesAllBlue(vector<int>& light) {    
    int ans = 0;
    int right = 0;
    for (int i = 0; i < light.size(); ++i) {
      right = max(right, light[i]);
      ans += right == i + 1;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1375. Bulb Switcher III appeared first on Huahua's Tech Road.

The returned string must contain only lowercase English letters. If there are multiples valid strings, return any of them.  

Example 1:

Input: n = 4
Output: "pppz"
Explanation: "pppz" is a valid string since the character 'p' occurs three times and the character 'z' occurs once. Note that there are many other valid strings such as "ohhh" and "love".

Example 2:

Input: n = 2
Output: "xy"
Explanation: "xy" is a valid string since the characters 'x' and 'y' occur once. Note that there are many other valid strings such as "ag" and "ur".

Example 3:

Input: n = 7
Output: "holasss"

Constraints:

• 1 <= n <= 500

Solution: Greedy

if n is odd, return n ‘a’s.
otherwise, return n -1 ‘a’s and 1 ‘b’

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

// Author: Huahua
class Solution {
public:
  string generateTheString(int n) {    
    return n & 1 ? string(n, 'a') : string(n - 1, 'a') + "b";
  }
};

# Author: Huahua
class Solution:
  def generateTheString(self, n: int) -> str:
    ans = ['a'] * n if n % 2 == 1 else ['a'] * (n - 1) + ['b']
    return ''.join(ans)

The post 花花酱 LeetCode 1374. Generate a String With Characters That Have Odd Counts appeared first on Huahua's Tech Road.

• Choose any node in the binary tree and a direction (right or left).
• If the current direction is right then move to the right child of the current node otherwise move to the left child.
• Change the direction from right to left or right to left.
• Repeat the second and third step until you can’t move in the tree.

Zigzag length is defined as the number of nodes visited – 1. (A single node has a length of 0).

Return the longest ZigZag path contained in that tree.

Example 1:

Input: root = [1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1]
Output: 3
Explanation: Longest ZigZag path in blue nodes (right -> left -> right).

Example 2:

Input: root = [1,1,1,null,1,null,null,1,1,null,1]
Output: 4
Explanation: Longest ZigZag path in blue nodes (left -> right -> left -> right).

Example 3:

Input: root = [1]
Output: 0

Constraints:

• Each tree has at most 50000 nodes..
• Each node’s value is between [1, 100].

Solution: Recursion

For each node return
1. max ZigZag length if go left
2. max ZigZag length if go right
3. maz ZigZag length within the subtree

ZigZag(root):
ll, lr, lm = ZigZag(root.left)
rl, rr, rm = ZigZag(root.right)
return (lr+1, rl + 1, max(lr+1, rl+1, lm, rm))

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

// Author: Huahua
class Solution {
public:
  int longestZigZag(TreeNode* root) {    
    return get<2>(ZigZag(root));
  }
    
  // Returns {left, right, max}
  tuple<int, int, int> ZigZag(TreeNode* root) {
    if (!root) return {-1, -1, -1};
    auto [ll, lr, lm] = ZigZag(root->left);
    auto [rl, rr, rm] = ZigZag(root->right);
    int l = lr + 1;
    int r = rl + 1;
    return {l, r, max({l, r, lm, rm})};
  }
};

# Author: Huahua
class Solution:
  def longestZigZag(self, root: TreeNode) -> int:
    def ZigZag(node):
      if not node: return (-1, -1, -1)
      ll, lr, lm = ZigZag(node.left)
      rl, rr, rm = ZigZag(node.right)
      return (lr + 1, rl + 1, max(lr + 1, rl + 1, lm, rm))
    return ZigZag(root)[2]

The post 花花酱 LeetCode 1372. Longest ZigZag Path in a Binary Tree appeared first on Huahua's Tech Road.

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

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:

Given the sorted array: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

Solution: Recursion

Recursively build a BST for a given range.

def build(nums, l, r):
if l > r: return None
m = l + (r – l) / 2
root = TreeNode(nums[m])
root.left = build(nums, l, m – 1)
root.right = build(nums, m + 1, r)
return root

return build(nums, 0, len(nums) – 1)

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

// Author: Huahua
class Solution {
public:
  TreeNode* sortedArrayToBST(vector<int>& nums) {
    function<TreeNode*(int l, int r)> build = [&](int l, int r) {
      if (l > r) return static_cast<TreeNode*>(nullptr);      
      int m = l + (r - l) / 2;
      TreeNode* root = new TreeNode(nums[m]);
      root->left = build(l, m - 1);
      root->right = build(m + 1, r);
      return root;
    };
    return build(0, nums.size() - 1);
  }
};

// Author: Huahua
class Solution {
  public TreeNode sortedArrayToBST(int[] nums) {
    return buildBST(nums, 0, nums.length - 1);
  }
  
  private TreeNode buildBST(int[] nums, int l, int r) {
    if (l > r) return null;
    int m = l + (r - l) / 2;
    TreeNode root = new TreeNode(nums[m]);
    root.left = buildBST(nums, l, m - 1);
    root.right = buildBST(nums, m + 1, r);
    return root;
  }
}

# Author: Huahua
class Solution:
  def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
    def buildBST(l: int, r: int) -> TreeNode:
      if l > r: return None
      m = l + (r - l) // 2
      root = TreeNode(nums[m])
      root.left = buildBST(l, m - 1)
      root.right = buildBST(m + 1, r)
      return root
    return buildBST(0, len(nums) - 1)

// Author: Huahua
var sortedArrayToBST = function(nums) {
  var buildBST = function(l, r) {    
    if (l > r) return null;
    let m = l + Math.floor((r - l) / 2);
    let root = new TreeNode(nums[m]);
    root.left = buildBST(l, m - 1);
    root.right = buildBST(m + 1, r);
    return root;
  }
  return buildBST(0, nums.length - 1);
};

The post 花花酱 LeetCode 108. Convert Sorted Array to Binary Search Tree appeared first on Huahua's Tech Road.

Example 1:

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

Example 2:

Input: nums = [5,1,1,2,0,0]
Output: [0,0,1,1,2,5]

Constraints:

• 1 <= nums.length <= 50000
• -50000 <= nums[i] <= 50000

Since n <= 50000, any O(n^2) won’t pass, we need O(nlogn) or better

Solution 1: QuickSort

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

// Author: Huahua, 60 ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    function<void(int, int)> quickSort = [&](int l, int r) {
      if (l >= r) return;      
      int i = l;
      int j = r;
      int p = nums[l + rand() % (r - l + 1)];
      while (i <= j) {
        while (nums[i] < p) ++i;
        while (nums[j] > p) --j;
        if (i <= j)
          swap(nums[i++], nums[j--]);
      }
      quickSort(l, j);
      quickSort(i, r);
    };
    quickSort(0, nums.size() - 1);
    return nums;
  }
};

Solution 2: Counting Sort

Time complexity: O(n)
Space complexity: O(max(nums) – min(nums))

// Author: Huahua, 54 ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    auto [min_it, max_it] = minmax_element(begin(nums), end(nums));
    int l = *min_it, r = *max_it;
    vector<int> count(r - l + 1);
    for (int n : nums) ++count[n - l];
    int index = 0;
    for (int i = 0; i < count.size(); ++i)
      while (count[i]--) nums[index++] = i + l;
    return nums;
  }
};

Solution 2: HeapSort

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

// Author: Huahua, 72ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    priority_queue<int> q(begin(nums), end(nums));
    int i = nums.size();
    while (!q.empty()) {
      nums[--i] = q.top();
      q.pop();
    }
    return nums;
  }
};

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    auto heapify = [&](int i, int e) {
      while (i <= e) {
        int l = 2 * i + 1;
        int r = 2 * i + 2;
        int j = i;
        if (l <= e && nums[l] > nums[j]) j = l;
        if (r <= e && nums[r] > nums[j]) j = r;
        if (j == i) break;
        swap(nums[i], nums[j]);
        swap(i, j);
      }
    };
    
    const int n = nums.size();
    
    // Init heap
    for (int i = n / 2; i >= 0; i--)
      heapify(i, n - 1);
    
    // Get min.
    for (int i = n - 1; i >= 1; i--) {
      swap(nums[0], nums[i]);
      heapify(0, i - 1);    
    }
    
    return nums;
  }
};

Solution 3: MergeSort

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

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    vector<int> t(nums.size());
    function<void(int, int)> mergeSort = [&](int l, int r) {
      if (l + 1 >= r) return;
      int m = l + (r - l) / 2;
      mergeSort(l, m);
      mergeSort(m, r);
      int i1 = l;
      int i2 = m;
      int index = 0;
      while (i1 < m || i2 < r)
        if (i2 == r || (i1 < m && nums[i1] < nums[i2]))
          t[index++] = nums[i1++];
        else
          t[index++] = nums[i2++];      
      std::copy(begin(t), begin(t) + index, begin(nums) + l);
    };
    
    mergeSort(0, nums.size());
    return nums;
  }
};

Solution 4: BST

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

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    multiset<int> s(begin(nums), end(nums));
    return {begin(s), end(s)};
  }
};

The post 花花酱 LeetCode 912. Sort an Array appeared first on Huahua's Tech Road.

Example 1:

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

Constraints:

• The number of nodes in the tree is between 1 and 10^4.
• The value of nodes is between 1 and 100.

Solution 1: Recursion

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

// Author: Huahua
class Solution {
public:
  int deepestLeavesSum(TreeNode* root) {
    int sum = 0;
    int max_depth = 0;
    function<void(TreeNode*, int)> dfs = [&](TreeNode* n, int d) {
      if (!n) return;
      if (d > max_depth) {
        max_depth = d;
        sum = 0;
      }
      if (d == max_depth) sum += n->val;
      dfs(n->left, d + 1);
      dfs(n->right, d + 1);
    };
    dfs(root, 0);
    return sum;
  }
};

The post 花花酱 LeetCode 1302. Deepest Leaves Sum appeared first on Huahua's Tech Road.

You may assume no duplicates in the array.

Example 1:

Input: [1,3,5,6], 5
Output: 2

Example 2:

Input: [1,3,5,6], 2
Output: 1

Example 3:

Input: [1,3,5,6], 7
Output: 4

Example 4:

Input: [1,3,5,6], 0
Output: 0

Solution: Binary Search

Find the number or upper bound if doesn’t exist.

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

// Author: Huahua
class Solution {
public:
  int searchInsert(vector<int>& nums, int target) {
    int l = 0, r = nums.size();
    while (l < r) {
      int m = l + (r - l) / 2;      
      if (nums[m] == target)
        return m;
      else if (nums[m] > target)
        r = m;
      else
        l = m + 1;
    }
    return l;
  }
};

The post 花花酱 LeetCode 35. Search Insert Position appeared first on Huahua's Tech Road.

Return a deep copy of the list.

The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:

• val: an integer representing Node.val
• random_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.

Example 1:

Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

Example 2:

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

Example 3:

Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]

Example 4:

Input: head = []
Output: []
Explanation: Given linked list is empty (null pointer), so return null.

Constraints:

• -10000 <= Node.val <= 10000
• Node.random is null or pointing to a node in the linked list.
• Number of Nodes will not exceed 1000.

Solution: Hashtable

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

// Author: Huahua
class Solution {
public:
  Node* copyRandomList(Node* head) {
    if (!head) return head;

    unordered_map<Node*, Node*> m;    
    Node* cur = m[head] = new Node(head->val);
    Node* ans = cur;

    while (head) {
      if (head->random) {
        auto it = m.find(head->random);
        if (it == end(m))
          it = m.emplace(head->random, new Node(head->random->val)).first;
        cur->random = it->second;
      }

      if (head->next) {
        auto it = m.find(head->next);
        if (it == end(m))
          it = m.emplace(head->next, new Node(head->next->val)).first;        
        cur->next = it->second;
      }

      head = head->next;
      cur = cur->next;
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 138. Copy List with Random Pointer appeared first on Huahua's Tech Road.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Given binary search tree:  root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Note:

• All of the nodes’ values will be unique.
• p and q are different and both values will exist in the BST.

Solution: Recursion

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

// Author: Huahua
class Solution {
public:
  TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {    
    if (p->val < root->val && q->val < root->val) 
      return lowestCommonAncestor(root->left, p, q);
    if (p->val > root->val && q->val > root->val)
      return lowestCommonAncestor(root->right, p, q);
    return root;
  }
};

The post 花花酱 LeetCode 235. Lowest Common Ancestor of a Binary Search Tree appeared first on Huahua's Tech Road.

Note: A leaf is a node with no children.

Example:

Input:

   1
 /   \
2     3
 \
  5

Output: ["1->2->5", "1->3"]

Explanation: All root-to-leaf paths are: 1->2->5, 1->3

Solution: Recursion

Time complexity: O(n)
Space complexity: O(n) / output can be O(n^2)

// Author: Huahua
class Solution {
public:
  vector<string> binaryTreePaths(TreeNode* root) {
    vector<string> ans;
    string s;
    function<void(TreeNode*, int)> preorder = [&](TreeNode* node, int l) {
      if (!node) return;
      s += (l > 0 ? "->" : "") + to_string(node->val);
      if (!node->left && !node->right)
        ans.push_back(s);
      preorder(node->left, s.size());
      preorder(node->right, s.size());
      while (s.size() != l) s.pop_back();
    };
    preorder(root, 0);
    return ans;
  }
};

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