D. J.:

- Added the Bottom Up (Tabulation) DP Solution for the leetcode problem 10

Author: nobodyPerfecZ

awesome_python_leetcode/_10_regular_expression_matching.py

@@ -1,7 +1,7 @@
 class Solution:
     """Base class for all LeetCode Problems."""
 
-    def isMatch(self, s: str, p: str) -> bool:
+    def isMatchTD(self, s: str, p: str) -> bool:
         """
         Given an input string s and a pattern p, implement regular expression matching
         with support for '.' and '*' where:
@@ -10,6 +10,7 @@ def isMatch(self, s: str, p: str) -> bool:
 
         The matching should cover the entire input string (not partial).
         """
+        # Top-Down Dynamic Programming (Memoization)
         # Time Complexity: O(n²)
         # Space Complexity: O(n²)
         dp = {}
@@ -32,3 +33,34 @@ def dfs(i: int, j: int) -> bool:
             return False
 
         return dfs(0, 0)
+
+    def isMatchBU(self, s: str, p: str) -> bool:
+        """
+        Given an input string s and a pattern p, implement regular expression matching
+        with support for '.' and '*' where:
+        - '.' Matches any single characters.
+        - '*' Matches zero or more of the preceding element.
+
+        The matching should cover the entire input string (not partial).
+        """
+        # Bottom-Up Dynamic Programming (Tabulation)
+        # Time Complexity: O(n²)
+        # Space Complexity: O(n²)
+        dp = [[False for _ in range(len(p) + 1)] for _ in range(len(s) + 1)]
+        dp[0][0] = True
+
+        # Initialize first row
+        for j in range(1, len(p) + 1):
+            if p[j - 1] == "*":
+                dp[0][j] = dp[0][j - 2]
+
+        # Fill the DP table
+        for i in range(1, len(s) + 1):
+            for j in range(1, len(p) + 1):
+                if p[j - 1] == "." or p[j - 1] == s[i - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                elif p[j - 1] == "*":
+                    dp[i][j] = dp[i][j - 2]
+                    if p[j - 2] == "." or p[j - 2] == s[i - 1]:
+                        dp[i][j] = dp[i][j] or dp[i - 1][j]
+        return dp[-1][-1]

tests/test_10_regular_expression_matching.py

@@ -14,7 +14,24 @@
         ("a", "ab*", True),
     ],
 )
-def test_func(s: str, p: str, expected: bool):
+def test_funcTD(s: str, p: str, expected: bool):
     """Tests the solution of a LeetCode problem."""
-    is_match = Solution().isMatch(s, p)
+    is_match = Solution().isMatchTD(s, p)
+    assert is_match is expected
+
+
+@pytest.mark.parametrize(
+    argnames=["s", "p", "expected"],
+    argvalues=[
+        ("aa", "a", False),
+        ("aa", "a*", True),
+        ("ab", ".*", True),
+        ("aab", "c*a*b", True),
+        ("ab", ".*c", False),
+        ("a", "ab*", True),
+    ],
+)
+def test_funcBU(s: str, p: str, expected: bool):
+    """Tests the solution of a LeetCode problem."""
+    is_match = Solution().isMatchBU(s, p)
     assert is_match is expected