代码随想录第38天 | 动态规划part01

代码随想录算法训练营第38天 | 动态规划part01

● 509. 斐波那契数
● 70. 爬楼梯
● 746. 使用最小花费爬楼梯

动态规划(Dynamic Programming)简称DP，
如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心.
贪心没有状态推导，而是从局部直接选最优的.

例如：有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

动态规划中dp[j]是由dp[j-weight[i]]推导出来的，然后取max(dp[j], dp[j - weight[i]] + value[i])。

动态规划的解题步骤:
做动规题目的时候，很多同学会陷入一个误区，就是以为把状态转移公式背下来，照葫芦画瓢改改，就开始写代码，甚至把题目AC之后，都不太清楚dp[i]表示的是什么。

这就是一种朦胧的状态，然后就把题给过了，遇到稍稍难一点的，可能直接就不会了，然后看题解，然后继续照葫芦画瓢陷入这种恶性循环中。

状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！
重点：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组
   一些同学可能想为什么要先确定递推公式，然后在考虑初始化呢？
   因为一些情况是递推公式决定了dp数组要如何初始化！

做动规的题目，写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。

题目一：斐波那契数

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给你n ，请计算 F(n) 。

本题最普通的方法是递归。

public int fib(int n) 
{
	if(n < 2)
		return n;
	return fib(n-1) +fib(n-2);
}

动态规划如下。
dp[i]的定义为：第i个数的斐波那契数值是dp[i]；
递推公式为状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];
初始化：dp[0] = 0; dp[1] = 1;
遍历的顺序：一定是从前到后遍历的
举例：举fib()的前几个数即可。

//dp
public int fib(int n) 
{
	//特殊
	if(n <= 1)
		return n;
	int[] dp = new int[n + 1];
	//初值
	dp[0] = 0;
	dp[1] = 1;
	for(int i=2; i<=n; i++)
	{
		dp[i] = dp[i-1] +dp[i-2];
	}
	return dp[n];
}

注意：dp[i]表示第i个斐波那契数，因此dp[0]无用，数组dp[n]只能最大到第n-1个数。
因此得定义成dp[n+1].

• 时间复杂度：O(n)
• 空间复杂度：O(n)

当然可以发现，我们只需要维护两个数值就可以了，不需要记录整个序列。
每次更新dp[0]与dp[1]即可避免空间的重复使用。

public int fib(int N) {
	if (N <= 1) 
		return N;
	int dp[2];
	dp[0] = 0;
	dp[1] = 1;
	for (int i = 2; i <= N; i++) 
	{
		int sum = dp[0] + dp[1];
		dp[0] = dp[1];
		dp[1] = sum;
	}
	return dp[1];
}

题目二：爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例：

• 输入： 2 输出： 2
• 解释： 有两种方法可以爬到楼顶。
  • 1 阶 + 1 阶
  • 2 阶

同理使用dp，
dp[i]： 爬到第i层楼梯，有dp[i]种方法.
爬到最后台子上为dp[n]，那么只有两种情况能到达这：
要么只差一步，爬一截到达；要么差两步，一次爬两个台阶到达(如果只爬一个，就到达了上面的另一种情况).
因此dp[n] = dp[n-1] + dp[n-2]。

那么dp[1] = 1，dp[2] = 2(到第二个台阶有两种方法);

遍历顺序：从前向后。还是斐波那契。

public int climbStairs(int n) 
{
	if(n <= 1)
		return n;
	int[] dp = new int[n+1];
	dp[1] = 1;
	dp[2] = 2;
	for(int i=3; i<=n; i++)
	{
		dp[i] = dp[i-1] + dp[i-2];
	}
	return dp[n];
}

题目三：使用最小花费爬楼梯

数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。
请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。(此时不花费，开始爬才花费)
示例 1：

• 输入：cost = [10, 15, 20]
• 输出：15
• 解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。

dp[n] :到达楼梯顶部阶梯花费的总体力
dp[n] = min(dp[n-1] + cost[n-1], dp[n-2] + cost[n-2])
只初始化dp[0]和dp[1]就够了，其他的最终都是dp[0]dp[1]推出。
dp[0] = 0, dp[1] = 0;
遍历时顺序遍历即可。

public int minCostClimbingStairs(int[] cost) 
{
	//
	int len = cost.length;
	int[] dp = new int[len + 1];
	dp[0] = 0;
	dp[1] = 0;
	for(int i=2; i<=len ;i++)
	{
		dp[i] = Math.min( dp[i-1]+cost[i-1] , dp[i-2]+cost[i-2] );
	}
	return dp[len];
}

同理有节省空间的版本。只需维护两个数即可，甚至可以连dp数组都不用。

public int minCostClimbingStairs(int[] cost) 
{
	//
	int len = cost.length;
	
	int[] dp = new int[2];
	dp[0] = 0;
	dp[1] = 0;
	for(int i=2; i<=len ;i++)
	{
		int cmp = Math.min( dp[1] + cost[i-1] , dp[0] + cost[i-2] );
		dp[0] = dp[1];
		dp[1] = cmp; 
	}
	return dp[1];
}