D. J.:

- Added Top-Down (Memoization) Solutions for the Leetcode Problems 70 and 509

Author: nobodyPerfecZ

awesome_python_leetcode/_509_fibonacci_number.py

@@ -1,7 +1,7 @@
 class Solution:
     """Base class for all LeetCode Problems."""
 
-    def fib(self, n: int) -> int:
+    def fibTD(self, n: int) -> int:
         """
         The Fibonacci numbers, commonly denoted F(n) form a sequence, called the
         Fibonacci sequence, such that each number is the sum of the two preceding ones,
@@ -12,10 +12,44 @@ def fib(self, n: int) -> int:
 
         Given n, calculate F(n).
         """
+        # Top-Down Dynamic Programming (Memoization)
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+
+        dp = {}
+
+        def dfs(m: int) -> int:
+            if m == 0:
+                return 0
+            elif m == 1:
+                return 1
+            elif m in dp:
+                return dp[m]
+            else:
+                dp[m - 1] = dfs(m - 1)
+                dp[m - 2] = dfs(m - 2)
+                dp[m] = dp[m - 1] + dp[m - 2]
+                return dp[m]
+
+        return dfs(n)
+
+    def fibBU(self, n: int) -> int:
+        """
+        The Fibonacci numbers, commonly denoted F(n) form a sequence, called the
+        Fibonacci sequence, such that each number is the sum of the two preceding ones,
+        starting from 0 and 1. That is,
+
+        F(0) = 0, F(1) = 1
+        F(n) = F(n - 1) + F(n - 2), for n > 1.
+
+        Given n, calculate F(n).
+        """
+        # Bottom-Up Dynamic Programming (Tabulation)
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+
         if n == 0:
             return 0
-        elif n <= 1:
-            return 1
 
         dp = [0 for _ in range(n + 1)]
         dp[1] = 1

awesome_python_leetcode/_70_climbing_stairs.py

@@ -1,13 +1,55 @@
 class Solution:
     """Base class for all LeetCode Problems."""
 
-    def climbStairs(self, n: int) -> int:
+    def climbStairsTD(self, n: int) -> int:
         """
         You are climbing a staircase. It takes n steps to reach the top.
 
         Each time you can either climb 1 or 2 steps. In how many distinct ways can you
         climb to the top?
         """
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+        dp = {}
+
+        def dfs(m: int) -> int:
+            if m == 0:
+                return 1
+            elif m == 1:
+                return 1
+            elif m in dp:
+                return dp[m]
+            else:
+                dp[m - 1] = dfs(m - 1)
+                dp[m - 2] = dfs(m - 2)
+                dp[m] = dp[m - 1] + dp[m - 2]
+                return dp[m]
+
+        return dfs(n)
+
+    def climbStairsBU(self, n: int) -> int:
+        """
+        You are climbing a staircase. It takes n steps to reach the top.
+
+        Each time you can either climb 1 or 2 steps. In how many distinct ways can you
+        climb to the top?
+        """
+        # Time Complexity: O(n)
+        # Space Complexity: O(n)
+        dp = [1 for _ in range(n + 1)]
+        for i in range(2, n + 1):
+            dp[i] = dp[i - 1] + dp[i - 2]
+        return dp[-1]
+
+    def climbStairsBUOptimized(self, n: int) -> int:
+        """
+        You are climbing a staircase. It takes n steps to reach the top.
+
+        Each time you can either climb 1 or 2 steps. In how many distinct ways can you
+        climb to the top?
+        """
+        # Time Complexity: O(n)
+        # Space Complexity: O(1)
         one, two = 1, 1
         for i in range(n - 1):
             tmp = one

tests/test_509_fibonacci_number.py

@@ -11,7 +11,21 @@
         (4, 3),
     ],
 )
-def test_func(n: int, expected: int):
+def test_funcTD(n: int, expected: int):
     """Tests the solution of a LeetCode problem."""
-    fn = Solution().fib(n)
+    fn = Solution().fibTD(n)
+    assert fn == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (2, 1),
+        (3, 2),
+        (4, 3),
+    ],
+)
+def test_funcBU(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    fn = Solution().fibBU(n)
     assert fn == expected

tests/test_70_climbing_stairs.py

@@ -10,7 +10,33 @@
         (3, 3),
     ],
 )
-def test_func(n: int, expected: int):
+def test_funcTD(n: int, expected: int):
     """Tests the solution of a LeetCode problem."""
-    combinations = Solution().climbStairs(n)
+    combinations = Solution().climbStairsTD(n)
+    assert combinations == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (2, 2),
+        (3, 3),
+    ],
+)
+def test_funcBU(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().climbStairsBU(n)
+    assert combinations == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (2, 2),
+        (3, 3),
+    ],
+)
+def test_funcBUOptimized(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    combinations = Solution().climbStairsBUOptimized(n)
     assert combinations == expected