# 70. Climbing Stairs

# 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]
```