D. J.:

- Added the leetcode problem and solution for 5, 63, 64, 72, 97, 120, 123, 188 and 221

Author: nobodyPerfecZ

README.md

@@ -28,6 +28,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [2 Add Two Numbers](https://leetcode.com/problems/add-two-numbers/description/)
 - [3 Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/description/)
 - [4 Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/description/)
+- [5 Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/description/)
 - [6 Zigzag Conversion](https://leetcode.com/problems/zigzag-conversion/description/)
 - [9 Palindrome Number](https://leetcode.com/problems/palindrome-number/description/)
 - [11 Container With Most Water](https://leetcode.com/problems/container-with-most-water/description/)
@@ -66,12 +67,15 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
 - [57 Insert Interval](https://leetcode.com/problems/insert-interval/description/)
 - [61 Rotate List](https://leetcode.com/problems/rotate-list/description/)
+- [63 Unique Paths II](https://leetcode.com/problems/unique-paths-ii/description/)
+- [64 Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/description/)
 - [66 Plus One](https://leetcode.com/problems/plus-one/description)
 - [67 Add Binary](https://leetcode.com/problems/add-binary/description/)
 - [68 Text Justification](https://leetcode.com/problems/text-justification/description/)
 - [69 Sqrt(x)](https://leetcode.com/problems/sqrtx/description/)
 - [70 Climbing Stairs](https://leetcode.com/problems/climbing-stairs/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
+- [72 Edit Distance](https://leetcode.com/problems/edit-distance/description/)
 - [73 Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/description/)
 - [74 Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/description/)
 - [76 Minimum Window Substring](https://leetcode.com/problems/minimum-window-substring/description/)
@@ -82,6 +86,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [86 Partition List](https://leetcode.com/problems/partition-list/description/)
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
 - [92 Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/description/)
+- [97 Interleaving String](https://leetcode.com/problems/interleaving-string/description/)
 - [98 Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/)
 - [100 Same Tree](https://leetcode.com/problems/same-tree/description/)
 - [101 Symmetric Tree](https://leetcode.com/problems/symmetric-tree/description/)
@@ -94,8 +99,10 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [112 Path Sum](https://leetcode.com/problems/path-sum/description/)
 - [114 Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/)
 - [117 Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/description/)
+- [120 Triangle](https://leetcode.com/problems/triangle/description/)
 - [121 Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 - [122 Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+- [123 Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
 - [124 Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/description/)
 - [125 Valid Palindrome](https://leetcode.com/problems/valid-palindrome/description/)
 - [127 Word Ladder](https://leetcode.com/problems/word-ladder/description/)
@@ -122,6 +129,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [169 Majority Element](https://leetcode.com/problems/majority-element/description/)
 - [172 Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
 - [173 Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/)
+- [188 Best Time to Buy and Sell Stock IV](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
 - [189 Rotate Array](https://leetcode.com/problems/rotate-array/description/)
 - [190 Reverse Bits](https://leetcode.com/problems/reverse-bits/description/)
 - [191 Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/description/)
@@ -138,6 +146,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [211 Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure/description/)
 - [212 Word Search II](https://leetcode.com/problems/word-search-ii/description/)
 - [219 Contains Duplicates II](https://leetcode.com/problems/contains-duplicate-ii/description/)
+- [221 Maximal Square](https://leetcode.com/problems/maximal-square/description/)
 - [222 Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/description/)
 - [224 Basic Calculator](https://leetcode.com/problems/basic-calculator/description/)
 - [226 Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/description/)

awesome_python_leetcode/_120_triangle.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minimumTotal(self, triangle: List[List[int]]) -> int:
+        """
+        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.
+        """
+        dp = [[float("inf")] * len(layer) for layer in triangle]
+        dp[-1] = triangle[-1]
+        for i in range(len(triangle) - 2, -1, -1):
+            for j in range(len(triangle[i])):
+                dp[i][j] = triangle[i][j] + min(dp[i + 1][j], dp[i + 1][j + 1])
+        return dp[0][0]

awesome_python_leetcode/_123_best_time_to_buy_and_sell_stock_III.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+        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).
+        """
+        dp = [0 for _ in range(len(prices))]
+
+        for t in range(1, 3):
+            pos = -prices[0]
+            profit = 0
+            for i in range(1, len(prices)):
+                pos = max(pos, dp[i] - prices[i])
+                profit = max(profit, pos + prices[i])
+                dp[i] = profit
+        return profit

awesome_python_leetcode/_188_best_time_to_buy_and_sell_stock_IV.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxProfit(self, k: int, prices: List[int]) -> int:
+        """
+        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).
+        """
+        dp = [0 for _ in range(len(prices))]
+
+        for t in range(1, k + 1):
+            pos = -prices[0]
+            profit = 0
+            for i in range(1, len(prices)):
+                pos = max(pos, dp[i] - prices[i])
+                profit = max(profit, pos + prices[i])
+                dp[i] = profit
+        return profit

awesome_python_leetcode/_221_maximal_square.py

@@ -0,0 +1,29 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maximalSquare(self, matrix: List[List[str]]) -> int:
+        """
+        Given an m x n binary matrix filled with 0's and 1's, find the largest square
+        containing only 1's and return its area.
+        """
+        dp = [[0 for _ in line] for line in matrix]
+        maxArea = 0
+
+        for i in range(len(matrix) - 1, -1, -1):
+            dp[i][-1] = int(matrix[i][-1])
+            maxArea = max(maxArea, dp[i][-1])
+
+        for j in range(len(matrix[0]) - 1, -1, -1):
+            dp[-1][j] = int(matrix[-1][j])
+            maxArea = max(maxArea, dp[-1][j])
+
+        for i in range(len(matrix) - 2, -1, -1):
+            for j in range(len(matrix[0]) - 2, -1, -1):
+                if matrix[i][j] == "0":
+                    continue
+                dp[i][j] = 1 + min(dp[i + 1][j], dp[i][j + 1], dp[i + 1][j + 1])
+                maxArea = max(maxArea, dp[i][j])
+        return maxArea**2

awesome_python_leetcode/_5_longest_palindromic_substring.py

@@ -0,0 +1,25 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def longestPalindrome(self, s: str) -> str:
+        """
+        Given a string s, return the longest palindromic substring in s.
+
+        A string is palindromic if it reads the same forward and backward.
+        """
+        res = ""
+        for i in range(len(s)):
+            left, right = i, i
+            while left >= 0 and right < len(s) and s[left] == s[right]:
+                if (right - left + 1) > len(res):
+                    res = s[left : right + 1]
+                left -= 1
+                right += 1
+
+            left, right = i, i + 1
+            while left >= 0 and right < len(s) and s[left] == s[right]:
+                if (right - left + 1) > len(res):
+                    res = s[left : right + 1]
+                left -= 1
+                right += 1
+        return res

awesome_python_leetcode/_63_unique_paths_II.py

@@ -0,0 +1,40 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        """
+        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.
+        """
+        if obstacleGrid[0][0] == 1:
+            return 0
+        dp = [[0] * len(line) for line in obstacleGrid]
+        dp[0][0] = 1
+        for i in range(1, len(obstacleGrid)):
+            if obstacleGrid[i][0]:
+                break
+            dp[i][0] = 1
+        for j in range(1, len(obstacleGrid[0])):
+            if obstacleGrid[0][j]:
+                break
+            dp[0][j] = 1
+        for i in range(1, len(obstacleGrid)):
+            for j in range(1, len(obstacleGrid[0])):
+                if obstacleGrid[i][j]:
+                    continue
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]

awesome_python_leetcode/_64_minimum_path_sum.py

@@ -0,0 +1,23 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minPathSum(self, grid: List[List[int]]) -> int:
+        """
+        Given a m x n grid filled with non-negative numbers, find a path from top left
+        to bottom right, which minimizes the sum of all numbers along its path.
+
+        Note: You can only move either down or right at any point in time.
+        """
+        dp = [[0] * len(line) for line in grid]
+        dp[0][0] = grid[0][0]
+        for j in range(1, len(dp[0])):
+            dp[0][j] = dp[0][j - 1] + grid[0][j]
+        for i in range(1, len(dp)):
+            dp[i][0] = dp[i - 1][0] + grid[i][0]
+        for i in range(1, len(dp)):
+            for j in range(1, len(dp[i])):
+                dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1])
+        return dp[-1][-1]

awesome_python_leetcode/_72_edit_distance.py

@@ -0,0 +1,28 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minDistance(self, word1: str, word2: str) -> int:
+        """
+        Given two strings word1 and word2, return the minimum number of operations
+        required to convert word1 to word2.
+
+        You have the following three operations permitted on a word:
+        - Insert a character
+        - Delete a character
+        - Replace a character
+        """
+        dp = [[0 for _ in range(len(word2) + 1)] for _ in range(len(word1) + 1)]
+
+        for i in range(len(word1) - 1, -1, -1):
+            dp[i][-1] = dp[i + 1][-1] + 1
+
+        for j in range(len(word2) - 1, -1, -1):
+            dp[-1][j] = dp[-1][j + 1] + 1
+
+        for i in range(len(word1) - 1, -1, -1):
+            for j in range(len(word2) - 1, -1, -1):
+                if word1[i] == word2[j]:
+                    dp[i][j] = dp[i + 1][j + 1]
+                else:
+                    dp[i][j] = 1 + min(dp[i][j + 1], dp[i + 1][j], dp[i + 1][j + 1])
+        return dp[0][0]

awesome_python_leetcode/_97_interleaving_string.py

@@ -0,0 +1,29 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
+        """
+        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.
+        """
+        if len(s1) + len(s2) != len(s3):
+            return False
+        dp = [[False for _ in range(len(s2) + 1)] for _ in range(len(s1) + 1)]
+        dp[-1][-1] = True
+        for i in range(len(s1), -1, -1):
+            for j in range(len(s2), -1, -1):
+                if i < len(s1) and (s3[i + j] == s1[i]) and dp[i + 1][j]:
+                    dp[i][j] = True
+                if j < len(s2) and (s3[i + j] == s2[j]) and dp[i][j + 1]:
+                    dp[i][j] = True
+        return dp[0][0]