Leetcode-day29-动态规划

动态规划解决的是什么问题？

如果某一问题有很多重叠子问题，使用动态规划是最有效的。

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

动态规划的常见问题类型：
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数组

    }
}

```