From 69132484ab8eb390b87dc3df28e2dc3ef1958ba4 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:05:59 +0530 Subject: [PATCH 1/6] Create 746. Min Cost Climbing Stairs.py Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- .../746. Min Cost Climbing Stairs.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py diff --git a/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py b/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py new file mode 100644 index 0000000..e69de29 From 5429f68e1cbc90281bf85976b431ffcf8fc58298 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:06:28 +0530 Subject: [PATCH 2/6] Update 746. Min Cost Climbing Stairs.py Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- .../746. Min Cost Climbing Stairs.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py b/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py index e69de29..e35506e 100644 --- a/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py +++ b/Solution/746. Min Cost Climbing Stairs/746. Min Cost Climbing Stairs.py @@ -0,0 +1,9 @@ +class Solution: + def minCostClimbingStairs(self, cost: List[int]) -> int: + @cache + def dfs(i: int) -> int: + if i >= len(cost): + return 0 + return cost[i] + min(dfs(i + 1), dfs(i + 2)) + + return min(dfs(0), dfs(1)) \ No newline at end of file From f9742844a2918129bde9159f60774ebdc98efec7 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:06:43 +0530 Subject: [PATCH 3/6] Create readme.md Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- Solution/746. Min Cost Climbing Stairs/readme.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Solution/746. Min Cost Climbing Stairs/readme.md diff --git a/Solution/746. Min Cost Climbing Stairs/readme.md b/Solution/746. Min Cost Climbing Stairs/readme.md new file mode 100644 index 0000000..e69de29 From 4aeb0245f6727c89082e34f5d350cd9d48d0f735 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:07:28 +0530 Subject: [PATCH 4/6] Update readme.md Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- .../746. Min Cost Climbing Stairs/readme.md | 461 ++++++++++++++++++ 1 file changed, 461 insertions(+) diff --git a/Solution/746. Min Cost Climbing Stairs/readme.md b/Solution/746. Min Cost Climbing Stairs/readme.md index e69de29..fa32817 100644 --- a/Solution/746. Min Cost Climbing Stairs/readme.md +++ b/Solution/746. Min Cost Climbing Stairs/readme.md @@ -0,0 +1,461 @@ +--- +comments: true +difficulty: Easy +edit_url: https://github.com/doocs/leetcode/edit/main/solution/0700-0799/0746.Min%20Cost%20Climbing%20Stairs/README_EN.md +tags: + - Array + - Dynamic Programming +--- + + + +# [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs) + +[中文文档](/solution/0700-0799/0746.Min%20Cost%20Climbing%20Stairs/README.md) + +## Description + + + +

You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.

+ +

You can either start from the step with index 0, or the step with index 1.

+ +

Return the minimum cost to reach the top of the floor.

+ +

 

+

Example 1:

+ +
+Input: cost = [10,15,20]
+Output: 15
+Explanation: You will start at index 1.
+- Pay 15 and climb two steps to reach the top.
+The total cost is 15.
+
+ +

Example 2:

+ +
+Input: cost = [1,100,1,1,1,100,1,1,100,1]
+Output: 6
+Explanation: You will start at index 0.
+- Pay 1 and climb two steps to reach index 2.
+- Pay 1 and climb two steps to reach index 4.
+- Pay 1 and climb two steps to reach index 6.
+- Pay 1 and climb one step to reach index 7.
+- Pay 1 and climb two steps to reach index 9.
+- Pay 1 and climb one step to reach the top.
+The total cost is 6.
+
+ +

 

+

Constraints:

+ + + + + +## Solutions + + + +### Solution 1: Memoization Search + +We design a function $\textit{dfs}(i)$, which represents the minimum cost required to climb the stairs starting from the $i$-th step. Therefore, the answer is $\min(\textit{dfs}(0), \textit{dfs}(1))$. + +The execution process of the function $\textit{dfs}(i)$ is as follows: + +- If $i \ge \textit{len(cost)}$, it means the current position has exceeded the top of the stairs, and there is no need to climb further, so return $0$; +- Otherwise, we can choose to climb $1$ step with a cost of $\textit{cost}[i]$, then recursively call $\textit{dfs}(i + 1)$; or we can choose to climb $2$ steps with a cost of $\textit{cost}[i]$, then recursively call $\textit{dfs}(i + 2)$; +- Return the minimum cost between these two options. + +To avoid repeated calculations, we use memoization search, saving the results that have already been calculated in an array or hash table. + +The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{cost}$. + + + +#### Python3 + +```python +class Solution: + def minCostClimbingStairs(self, cost: List[int]) -> int: + @cache + def dfs(i: int) -> int: + if i >= len(cost): + return 0 + return cost[i] + min(dfs(i + 1), dfs(i + 2)) + + return min(dfs(0), dfs(1)) +``` + +#### Java + +```java +class Solution { + private Integer[] f; + private int[] cost; + + public int minCostClimbingStairs(int[] cost) { + this.cost = cost; + f = new Integer[cost.length]; + return Math.min(dfs(0), dfs(1)); + } + + private int dfs(int i) { + if (i >= cost.length) { + return 0; + } + if (f[i] == null) { + f[i] = cost[i] + Math.min(dfs(i + 1), dfs(i + 2)); + } + return f[i]; + } +} +``` + +#### C++ + +```cpp +class Solution { +public: + int minCostClimbingStairs(vector& cost) { + int n = cost.size(); + int f[n]; + memset(f, -1, sizeof(f)); + auto dfs = [&](this auto&& dfs, int i) -> int { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = cost[i] + min(dfs(i + 1), dfs(i + 2)); + } + return f[i]; + }; + return min(dfs(0), dfs(1)); + } +}; +``` + +#### Go + +```go +func minCostClimbingStairs(cost []int) int { + n := len(cost) + f := make([]int, n) + for i := range f { + f[i] = -1 + } + var dfs func(int) int + dfs = func(i int) int { + if i >= n { + return 0 + } + if f[i] < 0 { + f[i] = cost[i] + min(dfs(i+1), dfs(i+2)) + } + return f[i] + } + return min(dfs(0), dfs(1)) +} +``` + +#### TypeScript + +```ts +function minCostClimbingStairs(cost: number[]): number { + const n = cost.length; + const f: number[] = Array(n).fill(-1); + const dfs = (i: number): number => { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = cost[i] + Math.min(dfs(i + 1), dfs(i + 2)); + } + return f[i]; + }; + return Math.min(dfs(0), dfs(1)); +} +``` + +#### Rust + +```rust +impl Solution { + pub fn min_cost_climbing_stairs(cost: Vec) -> i32 { + let n = cost.len(); + let mut f = vec![-1; n]; + + fn dfs(i: usize, cost: &Vec, f: &mut Vec, n: usize) -> i32 { + if i >= n { + return 0; + } + if f[i] < 0 { + let next1 = dfs(i + 1, cost, f, n); + let next2 = dfs(i + 2, cost, f, n); + f[i] = cost[i] + next1.min(next2); + } + f[i] + } + + dfs(0, &cost, &mut f, n).min(dfs(1, &cost, &mut f, n)) + } +} +``` + +#### JavaScript + +```js +function minCostClimbingStairs(cost) { + const n = cost.length; + const f = Array(n).fill(-1); + const dfs = i => { + if (i >= n) { + return 0; + } + if (f[i] < 0) { + f[i] = cost[i] + Math.min(dfs(i + 1), dfs(i + 2)); + } + return f[i]; + }; + return Math.min(dfs(0), dfs(1)); +} +``` + + + + + + + +### Solution 2: Dynamic Programming + +We define $f[i]$ as the minimum cost needed to reach the $i$-th stair. Initially, $f[0] = f[1] = 0$, and the answer is $f[n]$. + +When $i \ge 2$, we can reach the $i$-th stair directly from the $(i - 1)$-th stair with one step, or from the $(i - 2)$-th stair with two steps. Therefore, we have the state transition equation: + +$$ +f[i] = \min(f[i - 1] + \textit{cost}[i - 1], f[i - 2] + \textit{cost}[i - 2]) +$$ + +The final answer is $f[n]$. + +The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{cost}$. + + + +#### Python3 + +```python +class Solution: + def minCostClimbingStairs(self, cost: List[int]) -> int: + n = len(cost) + f = [0] * (n + 1) + for i in range(2, n + 1): + f[i] = min(f[i - 2] + cost[i - 2], f[i - 1] + cost[i - 1]) + return f[n] +``` + +#### Java + +```java +class Solution { + public int minCostClimbingStairs(int[] cost) { + int n = cost.length; + int[] f = new int[n + 1]; + for (int i = 2; i <= n; ++i) { + f[i] = Math.min(f[i - 2] + cost[i - 2], f[i - 1] + cost[i - 1]); + } + return f[n]; + } +} +``` + +#### C++ + +```cpp +class Solution { +public: + int minCostClimbingStairs(vector& cost) { + int n = cost.size(); + vector f(n + 1); + for (int i = 2; i <= n; ++i) { + f[i] = min(f[i - 2] + cost[i - 2], f[i - 1] + cost[i - 1]); + } + return f[n]; + } +}; +``` + +#### Go + +```go +func minCostClimbingStairs(cost []int) int { + n := len(cost) + f := make([]int, n+1) + for i := 2; i <= n; i++ { + f[i] = min(f[i-1]+cost[i-1], f[i-2]+cost[i-2]) + } + return f[n] +} +``` + +#### TypeScript + +```ts +function minCostClimbingStairs(cost: number[]): number { + const n = cost.length; + const f: number[] = Array(n + 1).fill(0); + for (let i = 2; i <= n; ++i) { + f[i] = Math.min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]); + } + return f[n]; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn min_cost_climbing_stairs(cost: Vec) -> i32 { + let n = cost.len(); + let mut f = vec![0; n + 1]; + for i in 2..=n { + f[i] = std::cmp::min(f[i - 2] + cost[i - 2], f[i - 1] + cost[i - 1]); + } + f[n] + } +} +``` + +#### JavaScript + +```js +function minCostClimbingStairs(cost) { + const n = cost.length; + const f = Array(n + 1).fill(0); + for (let i = 2; i <= n; ++i) { + f[i] = Math.min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]); + } + return f[n]; +} +``` + + + + + + + +### Solution 3: Dynamic Programming (Space Optimization) + +We notice that the state transition equation for $f[i]$ only depends on $f[i - 1]$ and $f[i - 2]$. Therefore, we can use two variables $f$ and $g$ to alternately record the values of $f[i - 2]$ and $f[i - 1]$, thus optimizing the space complexity to $O(1)$. + + + +#### Python3 + +```python +class Solution: + def minCostClimbingStairs(self, cost: List[int]) -> int: + f = g = 0 + for i in range(2, len(cost) + 1): + f, g = g, min(f + cost[i - 2], g + cost[i - 1]) + return g +``` + +#### Java + +```java +class Solution { + public int minCostClimbingStairs(int[] cost) { + int f = 0, g = 0; + for (int i = 2; i <= cost.length; ++i) { + int gg = Math.min(f + cost[i - 2], g + cost[i - 1]); + f = g; + g = gg; + } + return g; + } +} +``` + +#### C++ + +```cpp +class Solution { +public: + int minCostClimbingStairs(vector& cost) { + int f = 0, g = 0; + for (int i = 2; i <= cost.size(); ++i) { + int gg = min(f + cost[i - 2], g + cost[i - 1]); + f = g; + g = gg; + } + return g; + } +}; +``` + +#### Go + +```go +func minCostClimbingStairs(cost []int) int { + var f, g int + for i := 2; i <= n; i++ { + f, g = g, min(f+cost[i-2], g+cost[i-1]) + } + return g +} +``` + +#### TypeScript + +```ts +function minCostClimbingStairs(cost: number[]): number { + let [f, g] = [0, 0]; + for (let i = 1; i < cost.length; ++i) { + [f, g] = [g, Math.min(f + cost[i - 1], g + cost[i])]; + } + return g; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn min_cost_climbing_stairs(cost: Vec) -> i32 { + let (mut f, mut g) = (0, 0); + for i in 2..=cost.len() { + let gg = std::cmp::min(f + cost[i - 2], g + cost[i - 1]); + f = g; + g = gg; + } + g + } +} +``` + +#### JavaScript + +```js +function minCostClimbingStairs(cost) { + let [f, g] = [0, 0]; + for (let i = 1; i < cost.length; ++i) { + [f, g] = [g, Math.min(f + cost[i - 1], g + cost[i])]; + } + return g; +} +``` + + + + + + \ No newline at end of file From 132c47f52bd51d04d1e49e5505f71dcbe2f25e78 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:08:20 +0530 Subject: [PATCH 5/6] Update readme.md Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- Solution/746. Min Cost Climbing Stairs/readme.md | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/Solution/746. Min Cost Climbing Stairs/readme.md b/Solution/746. Min Cost Climbing Stairs/readme.md index fa32817..e61d1bc 100644 --- a/Solution/746. Min Cost Climbing Stairs/readme.md +++ b/Solution/746. Min Cost Climbing Stairs/readme.md @@ -1,18 +1,13 @@ + +# [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs) + --- comments: true difficulty: Easy -edit_url: https://github.com/doocs/leetcode/edit/main/solution/0700-0799/0746.Min%20Cost%20Climbing%20Stairs/README_EN.md tags: - Array - Dynamic Programming --- - - - -# [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs) - -[中文文档](/solution/0700-0799/0746.Min%20Cost%20Climbing%20Stairs/README.md) - ## Description From 0240e704937e0d9181a39d3766c51b35ed6ec810 Mon Sep 17 00:00:00 2001 From: Antim Pal <134076504+iamAntimPal@users.noreply.github.com> Date: Mon, 14 Apr 2025 21:09:09 +0530 Subject: [PATCH 6/6] Update readme.md Co-Authored-By: Antim-IWP <203163676+Antim-IWP@users.noreply.github.com> Co-Authored-By: Shiwangi Srivastava <174641070+IamShiwangi@users.noreply.github.com> --- Solution/746. Min Cost Climbing Stairs/readme.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Solution/746. Min Cost Climbing Stairs/readme.md b/Solution/746. Min Cost Climbing Stairs/readme.md index e61d1bc..bbe21f8 100644 --- a/Solution/746. Min Cost Climbing Stairs/readme.md +++ b/Solution/746. Min Cost Climbing Stairs/readme.md @@ -2,9 +2,9 @@ # [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs) --- -comments: true -difficulty: Easy -tags: +- **comments**: true +- **difficulty**: Easy +- **tags**: - Array - Dynamic Programming ---