63, 97, 120, 123, 188, 221, 300

Author: remy727

README.md

@@ -44,6 +44,7 @@
 | 58 | Length of Last Word | [Ruby](./algorithms/ruby/0058-length-of-last-word.rb) | Easy |
 | 59 | Spiral Matrix II | [Ruby](./algorithms/ruby/0059-spiral-matrix-ii.rb) | Medium |
 | 62 | Unique Paths | [Ruby](./algorithms/ruby/0062-unique-paths.rb) | Medium |
+| 63 | Unique Paths II | [Ruby](./algorithms/ruby/0063-unique-paths-ii.rb) | Medium |
 | 64 | Minimum Path Sum | [Ruby](./algorithms/ruby/0064-minimum-path-sum.rb) | Medium |
 | 66 | Plus One | [Ruby](./algorithms/ruby/0066-plus-one.rb) | Easy |
 | 67 | Add Binary | [Ruby](./algorithms/ruby/0067-add-binary.rb) [Python3](./algorithms/python3/0067-add-binary.py) | Easy |
@@ -59,6 +60,7 @@
 | 87 | Scramble String | [Ruby](./algorithms/ruby/0087-scramble-string.rb) | Hard |
 | 88 | Merge Sorted Array | [Ruby](./algorithms/ruby/0088-merge-sorted-array.rb) | Easy |
 | 91 | Decode Ways | [Ruby](./algorithms/ruby/0091-decode-ways.rb) | Medium |
+| 97 | Interleaving String | [Ruby](./algorithms/ruby/0097-interleaving-string.rb) | Medium |
 | 98 | Validate Binary Search Tree | [Ruby](./algorithms/ruby/0098-validate-binary-search-tree.rb) | Medium |
 | 100 | Same Tree | [Ruby](./algorithms/ruby/0100-same-tree.rb) | Easy |
 | 101 | Symmetric Tree | [Ruby](./algorithms/ruby/0101-symmetric-tree.rb) | Easy |
@@ -70,8 +72,10 @@
 | 109 | Convert Sorted List to Binary Search Tree | [Ruby](./algorithms/ruby/0109-convert-sorted-list-to-binary-search-tree.rb) | Medium |
 | 110 | Balanced Binary Tree | [Ruby](./algorithms/ruby/0110-balanced-binary-tree.rb) | Easy |
 | 113 | Path Sum II | [Ruby](./algorithms/ruby/0113-path-sum-ii.rb) | Medium |
+| 120 | Triangle | [Ruby](./algorithms/ruby/0120-triangle.rb) | Medium |
 | 121 | Best Time to Buy and Sell Stock | [Ruby](./algorithms/ruby/0121-best-time-to-buy-and-sell-stock.rb) | Easy |
 | 122 | Best Time to Buy and Sell Stock II | [Ruby](./algorithms/ruby/0122-best-time-to-buy-and-sell-stock-ii.rb) | Medium |
+| 123 | Best Time to Buy and Sell Stock III | [Ruby](./algorithms/ruby/0123-best-time-to-buy-and-sell-stock-iii.rb) | Hard |
 | 125 | Valid Palindrome | [Ruby](./algorithms/ruby/0125-valid-palindrome.rb) | Easy |
 | 128 | Longest Consecutive Sequence | [Ruby](./algorithms/ruby/0128-longest-consecutive-sequence.rb) | Medium |
 | 129 | Sum Root to Leaf Numbers | [Ruby](./algorithms/ruby/0129-sum-root-to-leaf-numbers.rb) | Medium |
@@ -89,6 +93,7 @@
 | 167 | Two Sum II - Input Array Is Sorted | [Ruby](./algorithms/ruby/0167-two-sum-ii-input-array-is-sorted.rb) | Medium |
 | 169 | Majority Element | [Ruby](./algorithms/ruby/0169-majority-element.rb) | Easy |
 | 173 | Binary Search Tree Iterator | [Ruby](./algorithms/ruby/0173-binary-search-tree-iterato.rb) | Medium |
+| 188 | Best Time to Buy and Sell Stock IV | [Ruby](./algorithms/ruby/0188-best-time-to-buy-and-sell-stock-iv.rb) | Hard |
 | 189 | Rotate Array | [Ruby](./algorithms/ruby/0189-rotate-array.rb) | Medium |
 | 198 | House Robber | [Ruby](./algorithms/ruby/0198-house-robber.rb) | Medium |
 | 199 | Binary Tree Right Side View | [Ruby](./algorithms/ruby/0199-binary-tree-right-side-view.rb) | Medium |
@@ -103,6 +108,7 @@
 | 215 | Kth Largest Element in an Array | [Ruby](./algorithms/ruby/0215-kth-largest-element-in-an-array.rb) | Medium |
 | 216 | Combination Sum III | [Ruby](./algorithms/ruby/0216-combination-sum-iii.rb) | Medium |
 | 219 | Contains Duplicate II | [Ruby](./algorithms/ruby/0219-contains-duplicate-ii.rb) | Easy |
+| 221 | Maximal Square | [Ruby](./algorithms/ruby/0221-maximal-square.rb) | Medium |
 | 224 | Basic Calculator | [Ruby](./algorithms/ruby/0224-basic-calculator.rb) | Hard |
 | 226 | Invert Binary Tree | [Ruby](./algorithms/ruby/0226-invert-binary-tree.rb) | Easy |
 | 227 | Basic Calculator II | [Ruby](./algorithms/ruby/0227-basic-calculator-ii.rb) | Medium |
@@ -121,6 +127,7 @@
 | 289 | Game of Life | [Ruby](./algorithms/ruby/0289-game-of-life.rb) | Medium |
 | 290 | Word Pattern | [Ruby](./algorithms/ruby/0290-word-pattern.rb) | Easy |
 | 299 | Bulls and Cows | [Ruby](./algorithms/ruby/0299-bulls-and-cows.rb) [Python3](./algorithms/python3/0299-bulls-and-cows.py) | Medium |
+| 300 | Longest Increasing Subsequence | [Ruby](./algorithms/ruby/0300-longest-increasing-subsequence.rb) | Medium |
 | 319 | Bulb Switcher | [Ruby](./algorithms/ruby/0319-bulb-switcher.rb) | Medium |
 | 322 | Coin Change | [Ruby](./algorithms/ruby/0322-coin-change.rb) | Medium |
 | 328 | Odd Even Linked List | [Ruby](./algorithms/ruby/0328-odd-even-linked-list.rb) | Medium |

algorithms/ruby/0063-unique-paths-ii.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# 63. Unique Paths II
+# https://leetcode.com/problems/unique-paths-ii
+# Medium
+
+=begin
+You are given an m x n integer array grid. There is a robot initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down or right at any point in time.
+
+An obstacle and space are marked as 1 or 0 respectively in grid. A path that the robot takes cannot include any square that is an obstacle.
+
+Return the number of possible unique paths that the robot can take to reach the bottom-right corner.
+
+The testcases are generated so that the answer will be less than or equal to 2 * 109.
+
+Example 1:
+Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+Output: 2
+Explanation: There is one obstacle in the middle of the 3x3 grid above.
+There are two ways to reach the bottom-right corner:
+1. Right -> Right -> Down -> Down
+2. Down -> Down -> Right -> Right
+
+Example 2:
+Input: obstacleGrid = [[0,1],[0,0]]
+Output: 1
+
+Constraints:
+m == obstacleGrid.length
+n == obstacleGrid[i].length
+1 <= m, n <= 100
+obstacleGrid[i][j] is 0 or 1.
+=end
+
+# @param {Integer[][]} obstacle_grid
+# @return {Integer}
+# @param {Integer[][]} obstacle_grid
+# @return {Integer}
+def unique_paths_with_obstacles(obstacle_grid)
+  hight = obstacle_grid.count
+  width = obstacle_grid[0].count
+
+  return 0 if hight * width == 0 || obstacle_grid[0][0] == 1
+
+  obstacle_grid[0][0] = 1
+
+  (1...hight).each do |y|
+    obstacle_grid[y][0] = obstacle_grid[y - 1][0] * (1 - obstacle_grid[y][0])
+  end
+
+  (1...width).each do |x|
+    obstacle_grid[0][x] = obstacle_grid[0][x - 1] * (1 - obstacle_grid[0][x])
+  end
+
+  (1...hight).each do |y|
+    (1...width).each do |x|
+      obstacle_grid[y][x] = (obstacle_grid[y][x - 1] + obstacle_grid[y - 1][x]) * (1 - obstacle_grid[y][x])
+    end
+  end
+
+  obstacle_grid[hight - 1][width - 1]
+end
+
+# ********************#
+#       TEST         #
+# ********************#
+
+require "test/unit"
+class Test_unique_paths_with_obstacles < Test::Unit::TestCase
+  def test_
+    assert_equal 2, unique_paths_with_obstacles([[0, 0, 0], [0, 1, 0], [0, 0, 0]])
+    assert_equal 1, unique_paths_with_obstacles([[0, 1], [0, 0]])
+  end
+end

algorithms/ruby/0097-interleaving-string.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# 97. Interleaving String
+# https://leetcode.com/problems/interleaving-string
+# Medium
+
+=begin
+Given strings s1, s2, and s3, find whether s3 is formed by an interleaving of s1 and s2.
+
+An interleaving of two strings s and t is a configuration where s and t are divided into n and m substrings respectively, such that:
+
+s = s1 + s2 + ... + sn
+t = t1 + t2 + ... + tm
+|n - m| <= 1
+The interleaving is s1 + t1 + s2 + t2 + s3 + t3 + ... or t1 + s1 + t2 + s2 + t3 + s3 + ...
+Note: a + b is the concatenation of strings a and b.
+
+Example 1:
+Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
+Output: true
+Explanation: One way to obtain s3 is:
+Split s1 into s1 = "aa" + "bc" + "c", and s2 into s2 = "dbbc" + "a".
+Interleaving the two splits, we get "aa" + "dbbc" + "bc" + "a" + "c" = "aadbbcbcac".
+Since s3 can be obtained by interleaving s1 and s2, we return true.
+
+Example 2:
+Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
+Output: false
+Explanation: Notice how it is impossible to interleave s2 with any other string to obtain s3.
+
+Example 3:
+Input: s1 = "", s2 = "", s3 = ""
+Output: true
+
+Constraints:
+0 <= s1.length, s2.length <= 100
+0 <= s3.length <= 200
+s1, s2, and s3 consist of lowercase English letters.
+=end
+
+# @param {String} s1
+# @param {String} s2
+# @param {String} s3
+# @return {Boolean}
+def is_interleave(s1, s2, s3)
+  return false if s1.length + s2.length != s3.length
+
+  row = [true] * (s2.length + 1)
+  (1...row.length).each do |j|
+    row[j] = row[j - 1] && s2[j - 1] == s3[j - 1]
+  end
+
+  s1.length.times do |i|
+    row[0] = row[0] && s1[i] == s3[i]
+    (1...row.length).each do |j|
+      row[j] = (row[j] && s1[i] == s3[i + j]) || (row[j - 1] && s2[j - 1] == s3[i + j])
+    end
+  end
+
+  row[-1]
+end
+
+# ********************#
+#       TEST         #
+# ********************#
+
+require "test/unit"
+class Test_is_interleave < Test::Unit::TestCase
+  def test_
+    assert_equal true, is_interleave("aabcc", "dbbca", "aadbbcbcac")
+    assert_equal false, is_interleave("aabcc", "dbbca", "aadbbbaccc")
+    assert_equal true, is_interleave("", "", "")
+  end
+end

algorithms/ruby/0120-triangle.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# 120. Triangle
+# https://leetcode.com/problems/triangle
+# Medium
+
+=begin
+Given a triangle array, return the minimum path sum from top to bottom.
+
+For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.
+
+Example 1:
+Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+Output: 11
+Explanation: The triangle looks like:
+   2
+  3 4
+ 6 5 7
+4 1 8 3
+The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
+
+Example 2:
+Input: triangle = [[-10]]
+Output: -10
+
+Constraints:
+1 <= triangle.length <= 200
+triangle[0].length == 1
+triangle[i].length == triangle[i - 1].length + 1
+-104 <= triangle[i][j] <= 104
+=end
+
+# @param {Integer[][]} triangle
+# @return {Integer}
+def minimum_total(triangle)
+  cost, last_cost = nil, nil
+  triangle.size.times do |i|
+    cost = triangle[triangle.size - i - 1]
+    cost.size.times { |j| cost[j] += [last_cost[j], last_cost[j + 1]].min } if i > 0
+    last_cost = cost
+  end
+  cost.first
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_minimum_total < Test::Unit::TestCase
+  def test_
+    assert_equal 11, minimum_total([[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]])
+    assert_equal(-10, minimum_total([[-10]]))
+  end
+end

algorithms/ruby/0123-best-time-to-buy-and-sell-stock-iii.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# 123. Best Time to Buy and Sell Stock III
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii
+# Hard
+
+=begin
+You are given an array prices where prices[i] is the price of a given stock on the ith day.
+
+Find the maximum profit you can achieve. You may complete at most two transactions.
+
+Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+Example 1:
+Input: prices = [3,3,5,0,0,3,1,4]
+Output: 6
+Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+
+Example 2:
+Input: prices = [1,2,3,4,5]
+Output: 4
+Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+
+Example 3:
+Input: prices = [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
+
+Constraints:
+1 <= prices.length <= 105
+0 <= prices[i] <= 105
+=end
+
+# @param {Integer[]} prices
+# @return {Integer}
+def max_profit(prices)
+  cost1 = cost2 = 100000
+  profit1 = profit2 = temp = 0
+  prices.each do |price|
+    cost1   = price if cost1 > price
+    profit1 = temp  if profit1 < temp = price - cost1
+    cost2   = temp  if cost2 > temp = price - profit1
+    profit2 = temp  if profit2 < temp = price - cost2
+  end
+  profit2
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_max_profit < Test::Unit::TestCase
+  def test_
+    assert_equal 6, max_profit([3, 3, 5, 0, 0, 3, 1, 4])
+    assert_equal 4, max_profit([1, 2, 3, 4, 5])
+    assert_equal 0, max_profit([7, 6, 4, 3, 1])
+  end
+end

algorithms/ruby/0188-best-time-to-buy-and-sell-stock-iv.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# 188. Best Time to Buy and Sell Stock IV
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv
+# Hard
+
+=begin
+You are given an integer array prices where prices[i] is the price of a given stock on the ith day, and an integer k.
+
+Find the maximum profit you can achieve. You may complete at most k transactions: i.e. you may buy at most k times and sell at most k times.
+
+Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+Example 1:
+Input: k = 2, prices = [2,4,1]
+Output: 2
+Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+
+Example 2:
+Input: k = 2, prices = [3,2,6,5,0,3]
+Output: 7
+Explanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+
+Constraints:
+1 <= k <= 100
+1 <= prices.length <= 1000
+0 <= prices[i] <= 1000
+=end
+
+# @param {Integer} k
+# @param {Integer[]} prices
+# @return {Integer}
+def max_profit(k, prices)
+  return 0 if prices.count < 2
+
+  n = prices.count
+  if k > n / 2
+    differences = (1..prices.count - 1).reduce([]) { |ar, i| ar << (prices[i] - prices[i - 1]) }
+    return differences.select { |num| num > 0 }.reduce(:+) || 0
+  end
+
+  d = Array.new(k + 1) { Array.new(n + 1) { 0 } }
+  (1..k).each do |i|
+    tmp_max = d[i - 1][0] - prices[0]
+
+    (1..n - 1).each do |j|
+      d[i][j] = [ d[i][j - 1], prices[j] + tmp_max ].max
+      tmp_max = [ tmp_max, d[i - 1][j] - prices[j] ].max
+    end
+  end
+
+  d[k][n - 1]
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_max_profit < Test::Unit::TestCase
+  def test_
+    assert_equal 2, max_profit(2, [2, 4, 1])
+    assert_equal 7, max_profit(2, [3, 2, 6, 5, 0, 3])
+  end
+end