动态规划解决的是什么问题?
如果某一问题有很多重叠子问题,使用动态规划是最有效的。
所以动态规划中每一个状态一定是由上一个状态推导出来的,这一点就区分于贪心,贪心没有状态推导,而是从局部直接选最优的,
动态规划的常见问题类型:
1.背包问题
2.打家劫舍
3.股票问题
4.子序列问题
动态规划五部曲:
1. 确定dp[] 的具体含义是什么,i代表什么,dp[i]代表什么
2.确定递推公式
3.确定dp的初始化
4.确定遍历方向
5.打印dp[]
这里用动态规划来做(也可以用递归)
1. dp数组 Dp[i]表示第i个斐波那契数
2.递推公式 题目里已经给出了
3.dp初始化 题目也给出了 dp[0]=0,dp[1]=1
4.遍历方向 从前往后,因为递推公式中需要前面的元素
5. 本题简单,不需要打印dp数组去debug
```
class Solution {
public int fib(int n) {
int[] dp = new int[n+1];
if(n<2){
return n;
}
dp[1]=1;
for(int i=2;i<=n;i++){
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
}
}
```
n阶楼梯,每次爬1或者2阶,有几种爬楼梯的方式
1.dp[]是爬到第i阶楼梯有多少种方式
2.递推公式,到第n阶楼梯只能从n-1往上一阶或者从n-2阶往上两阶,所以dp[n] = dp[n-1]+dp[n-2]
3.初始化,dp[1]=1,dp[2]=2
4.遍历方向,从前往后,因为后面的需要前面
5.dp数组遍历
```
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n+1];
if(n<3){ return n; }
dp[1]=1; dp[2]=2;
for(int i=3;i<=n;i++){ dp[i]=dp[i-1]+dp[i-2]; }
return dp[n]; } }
```
1.dp[] 到达第n阶需要的最小花费
2.确定递推公式 到达第n阶要么是从n-1一步上来,要么是从n-2两步上来,所以dp[n] = min(dp[n-1]+cost[n-1],dp[n-2]+cost[n-2])
3.dp数组初始化 从0或者从1上需要的花费都是0
4.遍历顺序 从前往后,确定元素需要前面的元素
```
class Solution {
public int minCostClimbingStairs(int[] cost) {
//1. dp数组的含义:表示到第i个楼梯所需要的最小费用
int dp[] = new int[cost.length+1];
//2. 递推公式 第n个楼梯可以由第n-1个楼梯往上一步或者第n-2个楼梯往上两步,分别需要的话费是cost[i-1],cost[i-1],这里要的是最小花费,所以dp[n]=min( , );
//3.初始化
dp[0]=0;
dp[1]=0;
//4.确定遍历顺序:从前往后,因为后面的值需要依靠前面的
for(int i=2;i<=cost.length;i++){
dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
}
return dp[cost.length];
//5。打印dp数组
}
}
```