To separate the digits of an integer is to get all the digits it has in the same order.

• For example, for the integer 10921, the separation of its digits is [1,0,9,2,1].

Example 1:

Input: nums = [13,25,83,77]
Output: [1,3,2,5,8,3,7,7]
Explanation: 
- The separation of 13 is [1,3].
- The separation of 25 is [2,5].
- The separation of 83 is [8,3].
- The separation of 77 is [7,7].
answer = [1,3,2,5,8,3,7,7]. Note that answer contains the separations in the same order.

Example 2:

Input: nums = [7,1,3,9]
Output: [7,1,3,9]
Explanation: The separation of each integer in nums is itself.
answer = [7,1,3,9].

Constraints:

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= 105

Solution: Stack

Time complexity: O(sum(log(nums[i]))
Space complexity: O(log(nums[i]))

// Author: Huahua
class Solution {
public:
  vector<int> separateDigits(vector<int>& nums) {
    vector<int> ans;
    for (int n : nums) {
      stack<int> cur;
      for (int x = n; x; x /= 10)
        cur.push(x % 10);
      while (!cur.empty())      
        ans.push_back(cur.top()), cur.pop();
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2553. Separate the Digits in an Array appeared first on Huahua's Tech Road.

1. Find any two adjacent numbers in nums that are non-coprime.
2. If no such numbers are found, stop the process.
3. Otherwise, delete the two numbers and replace them with their LCM (Least Common Multiple).
4. Repeat this process as long as you keep finding two adjacent non-coprime numbers.

Return the final modified array. It can be shown that replacing adjacent non-coprime numbers in any arbitrary order will lead to the same result.

The test cases are generated such that the values in the final array are less than or equal to 108.

Two values x and y are non-coprime if GCD(x, y) > 1 where GCD(x, y) is the Greatest Common Divisor of x and y.

Example 1:

Input: nums = [6,4,3,2,7,6,2]
Output: [12,7,6]
Explanation: 
- (6, 4) are non-coprime with LCM(6, 4) = 12. Now, nums = [12,3,2,7,6,2].
- (12, 3) are non-coprime with LCM(12, 3) = 12. Now, nums = [12,2,7,6,2].
- (12, 2) are non-coprime with LCM(12, 2) = 12. Now, nums = [12,7,6,2].
- (6, 2) are non-coprime with LCM(6, 2) = 6. Now, nums = [12,7,6].
There are no more adjacent non-coprime numbers in nums.
Thus, the final modified array is [12,7,6].
Note that there are other ways to obtain the same resultant array.

Example 2:

Input: nums = [2,2,1,1,3,3,3]
Output: [2,1,1,3]
Explanation: 
- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,3,3].
- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,3].
- (2, 2) are non-coprime with LCM(2, 2) = 2. Now, nums = [2,1,1,3].
There are no more adjacent non-coprime numbers in nums.
Thus, the final modified array is [2,1,1,3].
Note that there are other ways to obtain the same resultant array.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105
• The test cases are generated such that the values in the final array are less than or equal to 108.

Solution: Stack

“””It can be shown that replacing adjacent non-coprime numbers in any arbitrary order will lead to the same result.”””

So that we can do it in one pass from left to right using a stack/vector.

Push the current number onto stack, and merge top two if they are not co-prime.

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

// Author: Huahua
class Solution {
public:
  vector<int> replaceNonCoprimes(vector<int>& nums) {
    vector<int> ans;
    for (int x : nums) {
      ans.push_back(x);
      while (ans.size() > 1) {
        const int n1 = ans[ans.size() - 1]; 
        const int n2 = ans[ans.size() - 2]; 
        const int d = gcd(n1, n2);
        if (d == 1) break;
        ans.pop_back();
        ans.pop_back();
        ans.push_back(n1 / d * n2);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2197. Replace Non-Coprime Numbers in Array appeared first on Huahua's Tech Road.

Implement the MinStack class:

• MinStack() initializes the stack object.
• void push(int val) pushes the element val onto the stack.
• void pop() removes the element on the top of the stack.
• int top() gets the top element of the stack.
• int getMin() retrieves the minimum element in the stack.

Example 1:

Input
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

Output

[null,null,null,null,-3,null,0,-2]

Explanation MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); // return -3 minStack.pop(); minStack.top(); // return 0 minStack.getMin(); // return -2

Constraints:

• -231 <= val <= 231 - 1
• Methods pop, top and getMin operations will always be called on non-empty stacks.
• At most 3 * 104 calls will be made to push, pop, top, and getMin.

Solution 1: Two Stacks

One normal stack, one monotonic stack to store the min values.

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

// Author: Huahua
class MinStack {
public:
  void push(int x) {
    m_data.push(x);
    if (m_s.empty() || x <= m_s.top())
      m_s.push(x);
  }

  void pop() {
    if (!m_s.empty() && m_data.top() == m_s.top())
      m_s.pop();
    m_data.pop();
  }

  int top() {
    return m_data.top();
  }

  int getMin() {
    return m_s.empty() ? m_data.top() : m_s.top();
  }
private:
  stack<int> m_data;
  stack<int> m_s;
};

The post 花花酱 LeetCode 155. Min Stack appeared first on Huahua's Tech Road.

• positioni is the distance between the ith car and the beginning of the road in meters. It is guaranteed that positioni < positioni+1.
• speedi is the initial speed of the ith car in meters per second.

For simplicity, cars can be considered as points moving along the number line. Two cars collide when they occupy the same position. Once a car collides with another car, they unite and form a single car fleet. The cars in the formed fleet will have the same position and the same speed, which is the initial speed of the slowest car in the fleet.

Return an array answer, where answer[i] is the time, in seconds, at which the ith car collides with the next car, or -1 if the car does not collide with the next car. Answers within 10-5 of the actual answers are accepted.

Example 1:

Input: cars = [[1,2],[2,1],[4,3],[7,2]]
Output: [1.00000,-1.00000,3.00000,-1.00000]
Explanation: After exactly one second, the first car will collide with the second car, and form a car fleet with speed 1 m/s. After exactly 3 seconds, the third car will collide with the fourth car, and form a car fleet with speed 2 m/s.

Example 2:

Input: cars = [[3,4],[5,4],[6,3],[9,1]]
Output: [2.00000,1.00000,1.50000,-1.00000]

Constraints:

• 1 <= cars.length <= 105
• 1 <= positioni, speedi <= 106
• positioni < positioni+1

Solution: Monotonic Stack

Key observation: If my speed is slower than the speed of the previous car, not only mine but also all cars behind me will NEVER be able to catch/collide with the previous car. Such that we can throw it away.

Maintain a stack that stores the indices of cars with increasing speed.

Process car from right to left, for each car, pop the stack (throw the fastest car away) if any of the following conditions hold.
1) speed <= stack.top().speed
2) There are more than one car before me and it takes more than to collide the fastest car than time the fastest took to collide.

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

// Author: Huahua
class Solution {
public:
  vector<double> getCollisionTimes(vector<vector<int>>& cars) {
    auto collide = [&](int i, int j) -> double {
      return static_cast<double>(cars[i][0] - cars[j][0]) /
        (cars[j][1] - cars[i][1]);
    };
    const int n = cars.size();
    vector<double> ans(n, -1);
    stack<int> s;
    for (int i = n - 1; i >= 0; --i) {
      while (!s.empty() && (cars[i][1] <= cars[s.top()][1] ||
                           (s.size() > 1 && collide(i, s.top()) > ans[s.top()])))
        s.pop();
      ans[i] = s.empty() ? -1 : collide(i, s.top());
      s.push(i);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1776. Car Fleet II appeared first on Huahua's Tech Road.

• It is an empty string "", or a single character not equal to "(" or ")",
• It can be written as AB (A concatenated with B), where A and B are VPS‘s, or
• It can be written as (A), where A is a VPS.

We can similarly define the nesting depth depth(S) of any VPS S as follows:

• depth("") = 0
• depth(A + B) = max(depth(A), depth(B)), where A and B are VPS‘s
• depth("(" + A + ")") = 1 + depth(A), where A is a VPS.

For example, "", "()()", and "()(()())" are VPS‘s (with nesting depths 0, 1, and 2), and ")(" and "(()" are not VPS‘s.

Given a VPS represented as string s, return the nesting depth of s.

Example 1:

Input: s = "(1+(2*3)+((8)/4))+1"
Output: 3
Explanation: Digit 8 is inside of 3 nested parentheses in the string.

Example 2:

Input: s = "(1)+((2))+(((3)))"
Output: 3

Example 3:

Input: s = "1+(2*3)/(2-1)"
Output: 1

Example 4:

Input: s = "1"
Output: 0

Constraints:

• 1 <= s.length <= 100
• s consists of digits 0-9 and characters '+', '-', '*', '/', '(', and ')'.
• It is guaranteed that parentheses expression s is a VPS.

Solution: Stack

We only need to deal with ‘(‘ and ‘)’

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

// Author: Huahua
class Solution {
public:
  int maxDepth(string s) {
    int ans = 0;
    int d = 0;
    for (char c : s) {
      if (c == '(') ans = max(ans, ++d);
      else if (c == ')') --d;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1614. Maximum Nesting Depth of the Parentheses appeared first on Huahua's Tech Road.

A good string is a string which doesn’t have two adjacent characters s[i] and s[i + 1] where:

• 0 <= i <= s.length - 2
• s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case or vice-versa.

To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.

Return the string after making it good. The answer is guaranteed to be unique under the given constraints.

Notice that an empty string is also good.

Example 1:

Input: s = "leEeetcode"
Output: "leetcode"
Explanation: In the first step, either you choose i = 1 or i = 2, both will result "leEeetcode" to be reduced to "leetcode".

Example 2:

Input: s = "abBAcC"
Output: ""
Explanation: We have many possible scenarios, and all lead to the same answer. For example:
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""

Example 3:

Input: s = "s"
Output: "s"

Constraints:

• 1 <= s.length <= 100
• s contains only lower and upper case English letters.

Solution: Stack

Iterator over the string, compare current char with top of the stack, if they are a bad pair, pop the stack (remove both of them). Otherwise, push the current char onto the stack.

input: “abBAcC”
“a”
“ab”
“abB” -> “a”
“aA” -> “”
“c”
“cC” -> “”
ans = “”

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

class Solution {
public:
  string makeGood(string s) {
    string ans;
    for (char c : s) {      
      if (ans.length() && 
          abs(ans.back() - c) == abs('a' - 'A'))
        ans.pop_back();        
      else
        ans.push_back(c);
    }
    return ans;
  }
};

class Solution {
  public String makeGood(String s) {
    var sb = new StringBuilder();
    for (int i = 0; i < s.length(); ++i) {
      int l = sb.length();
      if (l > 0 && Math.abs(sb.charAt(l - 1) - s.charAt(i)) == 32) {
        sb.setLength(l - 1); // remove last char
      } else {
        sb.append(s.charAt(i));
      }
    }
    return sb.toString();
  }
}

class Solution:
  def makeGood(self, s: str) -> str:
    ans = []
    for c in s:
      if ans and abs(ord(ans[-1]) - ord(c)) == 32:
        ans.pop()
      else:
        ans.append(c)
    return "".join(ans)

The post 花花酱 LeetCode 1544. Make The String Great appeared first on Huahua's Tech Road.

Given the array prices where prices[i] is the price of the ith item in a shop. There is a special discount for items in the shop, if you buy the ith item, then you will receive a discount equivalent to prices[j] where j is the minimum index such that j > i and prices[j] <= prices[i], otherwise, you will not receive any discount at all.

Return an array where the ith element is the final price you will pay for the ith item of the shop considering the special discount.

Example 1:

Input: prices = [8,4,6,2,3]
Output: [4,2,4,2,3]
Explanation: 
For item 0 with price[0]=8 you will receive a discount equivalent to prices[1]=4, therefore, the final price you will pay is 8 - 4 = 4. 
For item 1 with price[1]=4 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 4 - 2 = 2. 
For item 2 with price[2]=6 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 6 - 2 = 4. 
For items 3 and 4 you will not receive any discount at all.

Example 2:

Input: prices = [1,2,3,4,5]
Output: [1,2,3,4,5]
Explanation: In this case, for all items, you will not receive any discount at all.

Example 3:

Input: prices = [10,1,1,6]
Output: [9,0,1,6]

Constraints:

• 1 <= prices.length <= 500
• 1 <= prices[i] <= 10^3

Solution 1: Simulation

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

// Author: Huahua
class Solution {
public:
  vector<int> finalPrices(vector<int> prices) {
    const int n = prices.size();
    for (int i = 0; i < n; ++i)      
      for (int j = i + 1; j < n; ++j)
        if (prices[j] <= prices[i]) {
          prices[i] -= prices[j];
          break;
        }     
    return prices;
  }
};

Solution 2: Monotonic Stack

Use a stack to store monotonically increasing items, when the current item is cheaper than the top of the stack, we get the discount and pop that item. Repeat until the current item is no longer cheaper or the stack becomes empty.

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

// Author: Huahua
class Solution {
public:
  vector<int> finalPrices(vector<int> prices) {
    // stores pointers of monotonically incraseing elements.
    stack<int*> s; 
    for (int& p : prices) {
      while (!s.empty() && *s.top() >= p) {
        *s.top() -= p;
        s.pop();
      }
      s.push(&p);
    }      
    return prices;
  }
};

index version

// Author: Huahua
class Solution {
public:
  vector<int> finalPrices(vector<int> prices) {
    // stores indices of monotonically incraseing elements.
    stack<int> s; 
    for (int i = 0; i < prices.size(); ++i) {
      while (!s.empty() && prices[s.top()] >= prices[i]) {
        prices[s.top()] -= prices[i];
        s.pop();
      }
      s.push(i);
    }      
    return prices;
  }
};

The post 花花酱 LeetCode 1475. Final Prices With a Special Discount in a Shop appeared first on Huahua's Tech Road.

Implement the CustomStack class:

• CustomStack(int maxSize) Initializes the object with maxSize which is the maximum number of elements in the stack or do nothing if the stack reached the maxSize.
• void push(int x) Adds x to the top of the stack if the stack hasn’t reached the maxSize.
• int pop() Pops and returns the top of stack or -1 if the stack is empty.
• void inc(int k, int val) Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, just increment all the elements in the stack.

Example 1:

Input
["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
Output
[null,null,null,2,null,null,null,null,null,103,202,201,-1]
Explanation
CustomStack customStack = new CustomStack(3); // Stack is Empty []
customStack.push(1);                          // stack becomes [1]
customStack.push(2);                          // stack becomes [1, 2]
customStack.pop();                            // return 2 --> Return top of the stack 2, stack becomes [1]
customStack.push(2);                          // stack becomes [1, 2]
customStack.push(3);                          // stack becomes [1, 2, 3]
customStack.push(4);                          // stack still [1, 2, 3], Don't add another elements as size is 4
customStack.increment(5, 100);                // stack becomes [101, 102, 103]
customStack.increment(2, 100);                // stack becomes [201, 202, 103]
customStack.pop();                            // return 103 --> Return top of the stack 103, stack becomes [201, 202]
customStack.pop();                            // return 202 --> Return top of the stack 102, stack becomes [201]
customStack.pop();                            // return 201 --> Return top of the stack 101, stack becomes []
customStack.pop();                            // return -1 --> Stack is empty return -1.

Solution: Simulation

Time complexity:
init: O(1)
pop: O(1)
push: O(1)
inc: O(k)

// Author: Huahua
class CustomStack {
public:
  CustomStack(int maxSize): max_size_(maxSize) {}

  void push(int x) {
    if (data_.size() == max_size_) return;
    data_.push_back(x);
  }

  int pop() {
    if (data_.empty()) return -1;
    int val = data_.back();
    data_.pop_back();
    return val;
  }

  void increment(int k, int val) {
    for (int i = 0; i < min(static_cast<size_t>(k), 
                            data_.size()); ++i)
      data_[i] += val;
  }
private:
  int max_size_;
  vector<int> data_;
};

/**
 * Your CustomStack object will be instantiated and called as such:
 * CustomStack* obj = new CustomStack(maxSize);
 * obj->push(x);
 * int param_2 = obj->pop();
 * obj->increment(k,val);
 */

The post 花花酱 LeetCode 1381. Design a Stack With Increment Operation appeared first on Huahua's Tech Road.

The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.

Example 1:

Input: "3+2*2"
Output: 7

Example 2:

Input: " 3/2 "
Output: 1

Example 3:

Input: " 3+5 / 2 "
Output: 5

Note:

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

Solution: Stack

if operator is ‘+’ or ‘-’, push the current num * sign onto stack.
if operator ‘*’ or ‘/’, pop the last num from stack and * or / by the current num and push it back to stack.

The answer is the sum of numbers on stack.

3+2*2 => {3}, {3,2}, {3, 2*2} = {3, 4} => ans = 7
3 +5/2 => {3}, {3,5}, {3, 5/2} = {3, 2} => ans = 5
1 + 2*3 – 5 => {1}, {1,2}, {1,2*3} = {1,6}, {1, 6, -5} => ans = 2

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

// Author: Huahua
class Solution {
public:
  int calculate(string s) {
    vector<int> nums;    
    char op = '+';
    int cur = 0;
    int pos = 0;
    while (pos < s.size()) {
      if (s[pos] == ' ') {
        ++pos;
        continue;
      }
      while (isdigit(s[pos]) && pos < s.size())
        cur = cur * 10 + (s[pos++] - '0');      
      if (op == '+' || op == '-') {
        nums.push_back(cur * (op == '+' ? 1 : -1));
      } else if (op == '*') {
        nums.back() *= cur;
      } else if (op == '/') {
        nums.back() /= cur;
      }
      cur = 0;      
      op = s[pos++];
    }
    return accumulate(begin(nums), end(nums), 0);
  }
};

# Author: Huahua
class Solution:
  def calculate(self, s: str) -> int:
    nums = []
    op = '+'
    cur = 0
    i = 0
    while i < len(s):
      if s[i] == ' ': 
        i += 1
        continue
      while i < len(s) and s[i].isdigit():
        cur = cur * 10 + ord(s[i]) - ord('0')
        i += 1      
      if op in '+-':
        nums.append(cur * (1 if op == '+' else -1))
      elif op == '*':
        nums[-1] *= cur
      elif op == '/':
        sign = -1 if nums[-1] < 0 or cur < 0 else 1
        nums[-1] = abs(nums[-1]) // abs(cur) * sign
      cur = 0
      if (i < len(s)): op = s[i]
      i += 1    
    return sum(nums)

Related Problems

• https://zxi.mytechroad.com/blog/recursion/leetcode-224-basic-calculator/
• https://zxi.mytechroad.com/blog/recursion/leetcode-736-parse-lisp-expression/
• https://zxi.mytechroad.com/blog/searching/leetcode-282-expression-add-operators/

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

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

Example:

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

Solution 1: Monotonic Stack

Use a monotonic stack to maintain the higher bars’s indices in ascending order.
When encounter a lower bar, pop the tallest bar and use it as the bottleneck to compute the area.

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

// Author: Huahua, 12ms, 10.7MB
class Solution {
public:
  int largestRectangleArea(vector<int>& heights) {
    heights.push_back(0);
    const int n = heights.size();
    stack<int> s;
    int ans = 0;
    int i = 0;
    while (i < n) {
      if (s.empty() || heights[i] >= heights[s.top()]) {
        s.push(i++);
      } else {
        int h = heights[s.top()]; s.pop();
        int w = s.empty() ? i : i - s.top() - 1;        
        ans = max(ans, h * w);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 84. Largest Rectangle in Histogram appeared first on Huahua's Tech Road.

In a UNIX-style file system, a period . refers to the current directory. Furthermore, a double period .. moves the directory up a level. For more information, see: Absolute path vs relative path in Linux/Unix

Note that the returned canonical path must always begin with a slash /, and there must be only a single slash / between two directory names. The last directory name (if it exists) must not end with a trailing /. Also, the canonical path must be the shortest string representing the absolute path.

Example 1:

Input: "/home/"
Output: "/home"
Explanation: Note that there is no trailing slash after the last directory name.

Example 2:

Input: "/../"
Output: "/"
Explanation: Going one level up from the root directory is a no-op, as the root level is the highest level you can go.

Example 3:

Input: "/home//foo/"
Output: "/home/foo"
Explanation: In the canonical path, multiple consecutive slashes are replaced by a single one.

Example 4:

Input: "/a/./b/../../c/"
Output: "/c"

Example 5:

Input: "/a/../../b/../c//.//"
Output: "/c"

Example 6:

Input: "/a//b////c/d//././/.."
Output: "/a/b/c"

Solution: Stack

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

// Author: Huahua
class Solution {
public:
  string simplifyPath(string path) {
    vector<string> s;
    int start = 1;
    for (int i = 1; i <= path.length(); ++i) {
      if (i == path.length() || path[i] == '/') {
        string p = path.substr(start, i - start);
        if (p == "/") continue;
        if (p == "..") {
          if (!s.empty()) s.pop_back();
        } else if (p.length() > 0 && p != ".") {
          s.push_back(std::move(p));
        }
        start = i + 1;
      }
    }

    string ans;
    for (int i = 0; i < s.size(); ++i)
      ans += "/" + s[i];
    return ans.empty() ? "/" : ans;
  }
};

The post 花花酱 LeetCode 71. Simplify Path appeared first on Huahua's Tech Road.

We repeatedly make k duplicate removals on s until we no longer can.

Return the final string after all such duplicate removals have been made.

It is guaranteed that the answer is unique.

Example 1:

Input: s = "abcd", k = 2
Output: "abcd"
Explanation: There's nothing to delete.

Example 2:

Input: s = "deeedbbcccbdaa", k = 3
Output: "aa"
Explanation: 
First delete "eee" and "ccc", get "ddbbbdaa"
Then delete "bbb", get "dddaa"
Finally delete "ddd", get "aa"

Example 3:

Input: s = "pbbcggttciiippooaais", k = 2
Output: "ps"

Constraints:

• 1 <= s.length <= 10^5
• 2 <= k <= 10^4
• s only contains lower case English letters.

Solution: Stack

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

// Author: Huahua
class Solution {
public:
  string removeDuplicates(string s, int k) {
    vector<pair<char, int>> st{{'*', 0}};
    for (char c : s)
      if (c != st.back().first)
        st.emplace_back(c, 1);
      else if (++st.back().second == k)
        st.pop_back();      
    string ans;
    for (const auto& p : st)
      ans.append(p.second, p.first);
    return ans;
  }
};

The post 花花酱 LeetCode 1209. Remove All Adjacent Duplicates in String II appeared first on Huahua's Tech Road.

Reverse the strings in each pair of matching parentheses, starting from the innermost one.

Your result should not contain any bracket.

Example 1:

Input: s = "(abcd)"
Output: "dcba"

Example 2:

Input: s = "(u(love)i)"
Output: "iloveu"

Example 3:

Input: s = "(ed(et(oc))el)"
Output: "leetcode"

Example 4:

Input: s = "a(bcdefghijkl(mno)p)q"
Output: "apmnolkjihgfedcbq"

Constraints:

• 0 <= s.length <= 2000
• s only contains lower case English characters and parentheses.
• It’s guaranteed that all parentheses are balanced.

Solution: Stack

Use a stack of strings to track all the active strings.
Iterate over the input string:
1. Whenever there is a ‘(‘, push an empty string to the stack.
2. Whenever this is a ‘)’, pop the top string and append the reverse of it to the new stack top.
3. Otherwise, append the letter to the string on top the of stack.

Once done, the (only) string on the top of the stack is the answer.

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

// Author: Huahua
class Solution {
public:
  string reverseParentheses(string s) {
    stack<string> st;
    st.push("");
    for (char c : s) {
      if (c == '(') st.push("");
      else if (c != ')') st.top() += c;
      else {
        string t = st.top(); st.pop();
        st.top().insert(end(st.top()), rbegin(t), rend(t));
      }
    }
    return st.top();
  }
};

The post 花花酱 LeetCode 1190. Reverse Substrings Between Each Pair of Parentheses appeared first on Huahua's Tech Road.

You have an infinite number of stacks arranged in a row and numbered (left to right) from 0, each of the stacks has the same maximum capacity.

Implement the DinnerPlates class:

• DinnerPlates(int capacity) Initializes the object with the maximum capacity of the stacks.
• void push(int val) pushes the given positive integer val into the leftmost stack with size less than capacity.
• int pop() returns the value at the top of the rightmost non-empty stack and removes it from that stack, and returns -1 if all stacks are empty.
• int popAtStack(int index) returns the value at the top of the stack with the given index and removes it from that stack, and returns -1 if the stack with that given index is empty.

Example:

Input: 
["DinnerPlates","push","push","push","push","push","popAtStack","push","push","popAtStack","popAtStack","pop","pop","pop","pop","pop"]
[[2],[1],[2],[3],[4],[5],[0],[20],[21],[0],[2],[],[],[],[],[]]
Output: 

[null,null,null,null,null,null,2,null,null,20,21,5,4,3,1,-1]

Explanation: 
DinnerPlates D = DinnerPlates(2);  // Initialize with capacity = 2
D.push(1);
D.push(2);
D.push(3);
D.push(4);
D.push(5);         // The stacks are now:  2  4
                                           1  3  5
                                           ﹈ ﹈ ﹈
D.popAtStack(0);   // Returns 2.  The stacks are now:     4
                                                       1  3  5
                                                       ﹈ ﹈ ﹈
D.push(20);        // The stacks are now: 20  4
                                           1  3  5
                                           ﹈ ﹈ ﹈
D.push(21);        // The stacks are now: 20  4 21
                                           1  3  5
                                           ﹈ ﹈ ﹈
D.popAtStack(0);   // Returns 20.  The stacks are now:     4 21
                                                        1  3  5
                                                        ﹈ ﹈ ﹈
D.popAtStack(2);   // Returns 21.  The stacks are now:     4
                                                        1  3  5
                                                        ﹈ ﹈ ﹈ 
D.pop()            // Returns 5.  The stacks are now:      4
                                                        1  3 
                                                        ﹈ ﹈  
D.pop()            // Returns 4.  The stacks are now:   1  3 
                                                        ﹈ ﹈   
D.pop()            // Returns 3.  The stacks are now:   1 
                                                        ﹈   
D.pop()            // Returns 1.  There are no stacks.
D.pop()            // Returns -1.  There are still no stacks.

Constraints:

• 1 <= capacity <= 20000
• 1 <= val <= 20000
• 0 <= index <= 100000
• At most 200000 calls will be made to push, pop, and popAtStack.

Solution: Array of stacks + TreeSet

Store all the stacks in an array, and store the indices of all free stacks in a tree set.
1. push(): find the first free stack and push onto it, if it becomes full, remove it from free set.
2. pop(): pop element from the last stack by calling popAtIndex(stacks.size()-1).
3. popAtIndex(): pop element from given index
3.1 add it to free set if it was full
3.2 remove it from free set if it becomes empty
3.2.1 remove it from stack array if it is the last stack

Time complexity:
Push: O(logn)
Pop: O(logn)
PopAtIndex: O(logn)

Space complexity: O(n)

// Author: Huahua
class DinnerPlates {
public:
  DinnerPlates(int capacity): cap_(capacity) {}

  void push(int val) {  
    int index = aval_.empty() ? stacks_.size() : *begin(aval_);
    if (index == stacks_.size()) stacks_.emplace_back();
    stack<int>& s = stacks_[index];
    s.push(val);
    if (s.size() == cap_)
      aval_.erase(index);
    else if (s.size() == 1) // only insert for the first element
      aval_.insert(index);
  }

  int pop() { return popAtStack(stacks_.size() - 1); }

  int popAtStack(int index) {
    if (index < 0 || index >= stacks_.size() || stacks_[index].empty()) return -1;
    stack<int>& s = stacks_[index];
    int val = s.top(); s.pop();
    if (s.size() == cap_ - 1) aval_.insert(index);    
    
    // Amortized O(1)
    auto it = prev(end(aval_));
    while (stacks_.size() && stacks_.back().empty()) {
      stacks_.pop_back();
      aval_.erase(it--);
    }
    return val;
  }
private:
  int cap_;
  set<int> aval_;
  vector<stack<int>> stacks_;
};

The post 花花酱 LeetCode 1172. Dinner Plate Stacks appeared first on Huahua's Tech Road.

• push(x) — Push element x to the back of queue.
• pop() — Removes the element from in front of queue.
• peek() — Get the front element.
• empty() — Return whether the queue is empty.

Example:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);  
queue.peek();  // returns 1
queue.pop();   // returns 1
queue.empty(); // returns false

Notes:

• You must use only standard operations of a stack — which means only push to top, peek/pop from top, size, and is empty operations are valid.
• Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
• You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

Solution: Use two stacks

amortized cost: O(1)

class MyQueue {
public:
  /** Initialize your data structure here. */
  MyQueue() {}

  /** Push element x to the back of queue. */
  void push(int x) {
    s1_.push(x);
  }

  /** Removes the element from in front of queue and returns that element. */
  int pop() {
    if (s2_.empty()) move();
    int top = s2_.top();
    s2_.pop();
    return top;
  }

  /** Get the front element. */
  int peek() {
    if (s2_.empty()) move();
    return s2_.top();
  }

  /** Returns whether the queue is empty. */
  bool empty() {
    return s1_.empty() && s2_.empty();
  }
private:
  stack<int> s1_;
  stack<int> s2_;
  
  void move() {
    while (!s1_.empty()) {
      s2_.push(s1_.top());
      s1_.pop();
    }
  }    
};

The post 花花酱 LeetCode 232. Implement Queue using Stacks appeared first on Huahua's Tech Road.