LeetCode - Easy - 746. Min Cost Climbing Stairs

Topic

• Array
• Dynamic Programming

Description

link

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:

• 2 <= cost.length <= 1000
• 0 <= cost[i] <= 999

Analysis

斐波那契数列题的进阶版

方法一：递归代码

方法二：使用缓存的递归代码

方法三：空间复杂度为O(n)的迭代代码

方法四：空间复杂度为O(1)的迭代代码

Submissions

public class MinCostClimbingStairs {

	//方法一：递归代码
	public int minCostClimbingStairs1(int[] cost) {
		int len = cost.length;
		return Math.min(helper1(cost, len - 2), helper1(cost, len - 1));
	}

	private int helper1(int[] cost, int i) {
		if (i < 2) {
			return cost[i];
		}
		return Math.min(helper1(cost, i - 2), helper1(cost, i - 1)) + cost[i];
	}

	//方法二：使用缓存的递归代码
	public int minCostClimbingStairs2(int[] cost) {
		int len = cost.length;
		int[] dp = new int[len];
		helper2(cost, len - 1, dp);
		return Math.min(dp[len - 2], dp[len - 1]);

	}

	private void helper2(int[] cost, int i, int[] dp) {
		if (i < 2) {
			dp[i] = cost[i];
		} else if (dp[i] == 0) {
			helper2(cost, i - 2, dp);
			helper2(cost, i - 1, dp);
			dp[i] = Math.min(dp[i - 2], dp[i - 1]) + cost[i];

		}
	}

	//方法三：空间复杂度为O(n)的迭代代码
	public int minCostClimbingStairs3(int[] cost) {
		int len = cost.length;
		int[] dp = new int[len];
		dp[0] = cost[0];
		dp[1] = cost[1];
		for (int i = 2; i < len; i++) {
			dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
		}
		return Math.min(dp[len - 2], dp[len - 1]);
	}

	//方法四：空间复杂度为O(1)的迭代代码
	public int minCostClimbingStairs4(int[] cost) {
		int len = cost.length;
		int[] dp = {cost[0], cost[1]};
		for (int i = 2; i < len; i++) {
			dp[i & 1] = Math.min(dp[0], dp[1]) + cost[i];
		}
		return Math.min(dp[0], dp[1]);
	}

}

Test

import static org.junit.Assert.*;

import org.junit.Test;

public class MinCostClimbingStairsTest {

	private MinCostClimbingStairs ms = new MinCostClimbingStairs();
	private int[] cost = {1, 100, 1, 1, 100, 1};
	
	@Test
	public void testMinCostClimbingStairs1() {
		assertEquals(4, ms.minCostClimbingStairs1(cost));
	}

	@Test
	public void testMinCostClimbingStairs2() {
		assertEquals(4, ms.minCostClimbingStairs2(cost));
	}

	@Test
	public void testMinCostClimbingStairs3() {
		assertEquals(4, ms.minCostClimbingStairs3(cost));
	}

	@Test
	public void testMinCostClimbingStairs4() {
		assertEquals(4, ms.minCostClimbingStairs4(cost));
	}

}