Problem

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?

Example 1:

Input: n = 2 Output: 2 Explanation: There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps

Example 2:

Input: n = 3 Output: 3 Explanation: There are three ways to climb to the top. 1. 1 step + 1 step + 1 step 2. 1 step + 2 steps 3. 2 steps + 1 step

Constraints:

• 1 <= n <= 45

Solution

This is Fibbonacci.

class Solution:
    def climbStairs(self, n: int) -> int:
        def fib(n):
            if n <= 1:
                return n
            return fib(n-1) + fib(n-2)
        return fib(n + 1)

This way times out. We need to remember the prevous steps.

We can use Python's built in cache for this:

from functools import lru_cache

class Solution:
    def climbStairs(self, n: int) -> int:
        @lru_cache
        def fib(n):
            if n <= 1:
                return n
            return fib(n-1) + fib(n-2)
        return fib(n + 1)

If this is not allowed we can also just build our own cache by using Dynamic Programming:

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = {}
        dp[0] = 0
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp [i - 2]
        return dp[n]