动态规划五部曲:
1.明确动态规划数组(dp)的下标及其元素的含义;
2.明确动态规划数组元素之间的递推关系;
3.明确动态规划数组的初始值;
4.明确遍历顺序(从前往后或从后往前);
5.打印动态规划数组,以便检查代码逻辑是否正确。
动态规划理论基础:代码随想录
leetcode 509 斐波那契数
class Solution {
public int[] dp = new int[31];
public int fib(int 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];
}
}
leetcode 70 爬楼梯
class Solution {
public int climbStairs(int n) {
//定义dp数组的下标为到楼顶的层数,dp数组的元素为方法总数
if(n == 1){
return 1;
}
int[] dp = new int[n + 1];
dp[0] = 0;
//初始化dp
dp[1] = 1;
dp[2] = 2;
//确定递推关系与遍历顺序
for(int i = 3; i <= n; i++){
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
}
leetcode 746 使用最小花费爬楼梯
class Solution {
public int min(int val1, int val2){
return val1 > val2 ? val2 : val1;
}
public int minCostClimbingStairs(int[] cost) {
//定义dp的含义:到达i位置的花销为dp[i]
//初始化dp数组
int[] dp = new int[cost.length + 1];
dp[1] = 0;
dp[2] = min(cost[0], cost[1]);
for(int i = 3; i <= cost.length; i++){
//确定递推关系和遍历顺序(注意使用一次爬两层时需要加上起始位置的花销即:cost[i - 2])
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[cost.length];
}
}
leetcode 62 不同路径
本题用到的dp数组是二维数组。
class Solution {
public int uniquePaths(int m, int n) {
//定义dp数组的含义:从start位置到(m, n)总共有dp[m][n]种不同的路径
int[][] dp = new int[m][n];
//初始化
for(int i = 0; i < n; i++){
dp[0][i] = 1;//因为只能向右走
}
for(int j = 0; j < m; j++){
dp[j][0] = 1;//因为只能向下走
}
//确定递推关系和遍历顺序:从左向右,从上往下
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
}
leetcode 63 不同路径(2)
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
//用没有障碍物的总路径之和减去到达障碍物的总路径之和
//定义dp
int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
//初始化dp
//若遇见障碍,则障碍后面的路径一定是0
for(int i = 0; i < obstacleGrid[0].length && obstacleGrid[0][i] == 0; i++){
dp[0][i] = 1;
}
for(int i = 0; i < obstacleGrid.length && obstacleGrid[i][0] == 0; i++){
dp[i][0] = 1;
}
//确定递推关系与遍历顺序
for(int i = 1; i < obstacleGrid.length; i++){
for(int j = 1; j < obstacleGrid[0].length; j++){
//只在没有遇到障碍的时候递推
if(obstacleGrid[i][j] != 1){
dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
}
}
}
//结果
return dp[obstacleGrid.length - 1][obstacleGrid[0].length - 1];
}
}
leetcode 343 整数拆分
要想将一个数拆分成各个整数并使其乘积最大,则应该数值近似相等的数越多越好。
递推公式:j * dp[i - j]。因为dp数组的含义是拆分i所能够得到的最大值,所以固定j的所有拆分情况中的最大值就是 j * dp[i - j]。(j - 1) * dp[i - j + 1] 便已经包含了 j * dp[i - j] 中再拆分j的所有情况。
class Solution {
public int max(int val1, int val2, int val3){
int temp = val1 > val2 ? val1 : val2;
return temp > val3 ? temp : val3;
}
public int integerBreak(int n) {
int[] dp = new int[n + 1];
//初始化dp
dp[0] = 0;
dp[1] = 0;
dp[2] = 1;
//递推
for(int i = 3; i <=n; i++){
for(int j = 1; j <= i / 2; j++){
//因为要尽可能使拆分得到的数相等,当j大于i / 2时,便不会满足此要求
//j * (i - j)表示拆分成两个数,j * dp[i - j]表示拆分成3及以上的数
dp[i] = max(j * (i - j), j * dp[i - j], dp[i]);
}
}
return dp[n];
}
}
leetcode 96 不同的二叉搜索树
class Solution {
public int numTrees(int n) {
//定义dp数组,dp[i]是当整数为i时按照题意所能拥有的BST的个数
int[] dp = new int[n + 1];
//初始化
dp[0] = 1;
//递推公式以及遍历
for(int i = 1; i <= n; i++){
for(int j = 1; j <= i; j++){
//从根节点为1起开始遍历,知道根节点为i时结束。最终的结果为依照遍历顺序累加,依据BST的性质,左子树的所有个数一定为dp[j - 1],右子树的所有个数一定是dp[i - j]。因为左子树一定比j小,右子树一定比j大,而所有节点的值均由1到i递增1组成。
dp[i] += dp[j - 1] * dp[i - j];
}
}
return dp[n];
}
}