509.斐波那契数
代码:
class Solution {
public int fib(int n) {
if (n==0||n==1) {
return n;
}
//1.确认dp数组和下标含义,一维dp数组,第i个数据为第i个数的的fn的值
int[] dp = new int[n+1];
//2.确认递推公式 fn = f(n-1)+f(n-2)
//3.初始化dp数组,dp[0] = 0, dp[1] = 1
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
//4.确认遍历顺序
//5.举例推导函数
return dp[n];
}
}
70.爬楼梯
class Solution {
public int climbStairs(int n) {
if (n==1) {
return 1;
}
if (n==2) {
return 2;
}
//确认dp数组的含义
int[] dp = new int[n+1];
//确认递推公式 dp[n] = dp[n-1] + dp[n-2];
//确认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];
}
}
746.使用最小花费爬楼梯
class Solution {
public int minCostClimbingStairs(int[] cost) {
//确认dp数组;dp[i] 表示跳到第i层楼梯并且再继续往上爬的最小支付费用
int[] dp = new int[cost.length];
//确认递推公式 dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
//dp数组初始化
dp[0] = cost[0];
dp[1] = cost[1];
if (cost.length == 2) {
return Math.min(dp[0], dp[1]);
}
//确认遍历的顺序
for (int i = 2; i < cost.length; i++) {
dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
}
//举例推导函数
return Math.min(dp[cost.length-1], dp[cost.length-2]);
}
}
62.不同路径
class Solution {
public int uniquePaths(int m, int n) {
/**
* 这一题思考了一下,如果想到达终点,那么就只能从终点的上一个位置或者从终点的左侧位置到达,
* 那么可以推导出 dp[m][n] = dp[m-1][n] + dp[m][n-1];
**/
if (m == 1||n==1) {
return 1;
}
//确定dp数组
int[][] dp = new int[m+1][n+1];
//确认递推公式,dp[m][n] = dp[m-1][n] + dp[m][n-1];
//dp数组的初始化,先给第二列和第二行的数据都调整为1
for (int i = 1; i < m+1; i++) {
dp[i][1] = 1;
}
for (int i = 1; i < n+1; i++) {
dp[1][i] = 1;
}
//确认dp数组的遍历顺序,从第二列第二行开始遍历整个表格,
for (int i = 2; i < m+1; i++) {
for (int j = 2; j < n+1; j++) {
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
//举例推导函数
return dp[m][n];
}
}
63.不同路径II
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
if (obstacleGrid[0][0] == 1) {
return 0;
}
if (obstacleGrid[m-1][n-1] == 1) {
return 0;
}
if (m==1||n==1) {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (obstacleGrid[i][j] == 1) {
return 0;
}
}
}
return 1;
}
//确认dp数组
int[][] dp = new int[m+1][n+1];
//确认递推公式 递推函数依然为 dp[i][j] = dp[i][j-1] + dp[i-1][j];
//初始化递推数组
dp[1][1] = 1;
//确认遍历顺序
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (i==1&&j==1) continue;
if (obstacleGrid[i-1][j-1] == 1) {
dp[i][j] = 0;
} else {
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
}
//举例推导函数
return dp[m][n];
}
}
343.整数拆分
class Solution {
public int integerBreak(int n) {
if (n == 2) {
return 1;
}
//确认dp数组含义
int[] dp = new int[n+1];
//确认递推公式, dp[i] = Math.max(dp[i], Math.max(dp[j]*(i-j), (i-j) * j));
//dp数组初始化
dp[2] = 1;
//确认dp数组的遍历顺序
for (int i = 3; i <= n; i++) {
for (int j = 1; j < i-1; j++) {
dp[i] = Math.max(dp[i], Math.max(dp[j] * (i-j), (i-j) * j));
}
}
//举例推导结果函数
return dp[n];
}
}