leetcode刷题｜动态规划-什么是动态规划？

最新推荐文章于 2024-10-14 18:52:56 发布

Alice_small

最新推荐文章于 2024-10-14 18:52:56 发布

阅读量81

点赞数

文章标签： leetcode 动态规划算法

本文链接：https://blog.csdn.net/xiaoxiao_tx/article/details/134744367

版权

动态规划

什么是动态规划

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

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

动态规划五部曲

确定dp[i]数组及i的含义
确定推导公式
dp数组的初始化
确定数组遍历顺序
举例推导

509.斐波那契数

力扣链接

题解

Java代码

class Solution {
    public int fib(int n) {
        //动态规划五部曲
        /**
           1. 确认dp[i]及i下标的含义：dp[i]是第i个的和
           2. 确认递推公式：dp[i] = dp[i-1] + dp[i-2]
           3. 确认dp数组初始化：dp[0] = 0; dp[1] = 1;
           4. 确认遍历顺序: 从前往后  
           5. 举例推导dp数组
         */
         if (n <= 1) {
             return n;
         }

         int[] dp= new int[n+1]; //长度为n+1，因为需要统计n的值，则索引要包含n
         dp[0] = 0;
         dp[1] = 1;
         
         for (int i = 2; i <= n; i++) {
             dp[i] = dp[i-1] + dp[i-2];
         }
         return dp[n];
    }
}

70.爬楼梯

力扣链接

题解

Java代码

class Solution {
    public int climbStairs(int n) {
        //确定dp数组及i的含义：第i个台阶的爬到楼顶的方法是dp[i]
        //确定递推公式：dp[i] = dp[i-1]+dp[i-2]
        //dp数组的初始化：dp[1] = 1; dp[2] = 2;
        //确认dp数组的遍历顺序：从前往后遍历
        //举例推导dp数组
        if (n < 2) {
            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];
    }
}

746.使用最小花费爬楼梯

力扣链接

题解

Java代码

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        //确定dp数组及i的含义：第i个台阶的爬楼梯的花费是dp[i]
        //确定递推公式：dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
        //dp数组的初始化：dp[0] = 0; dp[1] = 0;
        //确认dp数组的遍历顺序：从前往后遍历
        //举例推导dp数组
        if (cost.length == 0) {
            return 0;
        }        
        int[] dp = new int[cost.length+1];
        //跳到下标0 或 1 不需要花费，从下标0 1 开始跳则需要花费
        dp[0] = 0;
        dp[1] = 0;
        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];
    }
}