1137. 第 N 个泰波那契数
题目描述:
状态表示:
dp[i]表示第i个泰波那契数。
状态转移方程:
dp[i]=dp[i-3]+dp[i-2]+dp[i-1]。
初始化:
动态规划问题的初始化就是为了去避免初始情况下的越界问题。这里就对dp[0]=0,dp[1]=1,dp[2]=1这样进行初始化即可,题目已经给出了,非常简单。
填表顺序:
显而易见填表顺序为从左到右。
返回值:
因为dp[i]表示第i个泰波那契数,题目要求计算第n个斐波那契数,因此返回dp[n]即可。
代码如下:
经过以上过程之后编写代码还要注意一个细节,注意要提前根据n的大小进行判断,如果数组大小小于等于2但是未经过判断,后面的初始化就会出现越界问题。
class Solution {
public int tribonacci(int n) {
int[] dp = new int[n + 1];
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
if (n == 2) {
return 1;
}
dp[0] = 0;
dp[1] = 1;
dp[2] = 1;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 3] + dp[i - 2] + dp[i - 1];
}
return dp[n];
}
}
题目链接
时间复杂度:O(n)
空间复杂度:O(n)
空间优化版本:
class Solution {
public int tribonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
if (n == 2) {
return 1;
}
int num1 = 0;
int num2 = 1;
int num3 = 1;
int num4 = 0;
for (int i = 0; i <= n - 3; i++) {
num4 = num1 + num2 + num3;
num1 = num2;
num2 = num3;
num3 = num4;
}
return num3;
}
}
面试题 08.01. 三步问题
题目描述:
状态表示:
dp[i]表示达到第i阶台阶有多少种方法。
状态转移方程:
dp[i]=dp[i-1]+dp[i-2]+dp[i-3]。
初始化:
还是为了防止越界,初始化dp[1]=0,dp[2]=2,dp[0]=1。
填表顺序:
从左至右。
返回值:
返回dp[n]。
代码如下:
class Solution {
public int waysToStep(int n) {
int[] dp = new int[n + 1];
if (n == 0 || n == 1) {
return 1;
}
if (n == 2) {
return 2;
}
dp[0] = 1;
dp[1] = 1;
dp[2] = 2;
int MOD = (int) 1e9 + 7;
for (int i = 3; i <= n; i++) {
dp[i] = ((dp[i - 1] + dp[i - 2]) % MOD + dp[i - 3]) % MOD;
}
return dp[n];
}
}
题目链接
时间复杂度:O(n)
空间复杂度:O(n)
746. 使用最小花费爬楼梯
题目描述:
状态表示:
第一种方法,dp[i]表示到达第i个台阶使用的最低费用。
第二种方法,dp[i]表示从第i个台阶到达最顶部的最低费用。
状态转移方程:
dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])。
dp[i]=min(dp[i+1]+dp[i+2])+cost[i]。
初始化:
方法一要避免越界,初始化dp[0]=0,dp[1]=0。
方法二要避免越界,初始化dp[n-1]=cost[i],dp[n]=0。
填表顺序:
方法一从左至右,方法二从右至左。
返回值:
方法一返回值为dp[n],这里的n是cost数组的长度。
方法二返回值为min(dp[0],dp[1])。
方法一代码如下:
class Solution {
public int minCostClimbingStairs(int[] cost) {
int n = cost.length;
int[] dp = new int[n + 1];
for (int i = 2; i <= n; i++) {
dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[n];
}
}
方法二代码如下:
class Solution {
public int minCostClimbingStairs(int[] cost) {
int n = cost.length;
int[] dp = new int[n + 1];
dp[n] = 0;
dp[n - 1] = cost[n - 1];
for (int i = n - 2; i >= 0; i--) {
dp[i] = Math.min(dp[i + 1], dp[i + 2]) + cost[i];
}
return Math.min(dp[0], dp[1]);
}
}
题目链接
方法一和方法二的时空复杂度相同如下:
时间复杂度:O(n)
空间复杂度:O(n)