代码随想录算法训练营第38天|509. 斐波那契数，70. 爬楼梯，746. 使用最小花费爬楼梯
509. 斐波那契数
力扣题目链接
思路
动态规划
- dp[i]的定义为：第i个数的斐波那契数值是dp[i]
- 状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];
- 初始化：dp[0] = 0; dp[1] = 1;
- 从前往后遍历
矩阵快速幂
通项公式
代码
动态规划
class Solution {
public:
int fib(int N) {
if (N <= 1) return N;
vector dp(N + 1);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= N; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[N];
}
};
优化
class Solution {
public:
int fib(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
int f0 = 0, f1 = 1, f2;
for (int i = 2; i <= n; i++){
f2 = f0 + f1;
f0 = f1;
f1 = f2;
}
return f2;
}
};
- 时间复杂度
O(n) - 空间复杂度
O(1)
递归
class Solution {
public:
int fib(int n) {
if (n == 0) return 0;
else if (n == 1) return 1;
else return fib(n - 1) + fib(n - 2);
}
};
- 时间复杂度：O(2^n)
- 空间复杂度：O(n)
矩阵快速幂
class Solution {
public:
int fib(int n) {
if (n < 2) return n;
vector> q{{1, 1}, {1, 0}};
vector> res = matrix_pow(q, n - 1);
return res[0][0];
}
vector> matrix_pow(vector>& a, int n) {
vector> ret{{1, 0}, {0, 1}}; // 单位矩阵
while (n > 0) {
if (n & 1) {
ret = matrix_multiply(ret, a);
}
n >>= 1;
a = matrix_multiply(a, a);
}
return ret;
}
vector> matrix_multiply(vector>& a, vector>& b) {
vector> c{{0, 0}, {0, 0}};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
}
}
return c;
}
};
- 时间复杂度
O(logn) - 空间复杂度
O(1)
通项公式
class Solution {
public int fib(int n) {
double sqrt5 = Math.sqrt(5);
double fibN = Math.pow((1 + sqrt5) / 2, n) - Math.pow((1 - sqrt5) / 2, n);
return (int) Math.round(fibN / sqrt5);
}
}
70. 爬楼梯
力扣题目链接
思路
动态规划常规解法可以分成多个子问题，爬第n阶楼梯的方法数量，等于2部分之和
- 爬上n−1阶楼梯的方法数量。因为再爬1阶就能到第n阶
- 爬上n−2阶楼梯的方法数量，因为再爬2阶就能到第n阶
- 状态转移方程：dp[i] = dp[i - 1] + dp[i - 2]
- 初始化dp[1] = 1; dp[2] = 2;
代码
class Solution {
public:
int climbStairs(int n) {
if (n == 1) return 1;
int dp[4];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[3] = dp[2] + dp[1];
dp[1] = dp[2];
dp[2] = dp[3];
}
return dp[2];
}
};
- 时间复杂度
O(n) - 空间复杂度
O(1)
746. 使用最小花费爬楼梯
力扣题目链接
思路
-
dp[i] 表示走到第i阶楼梯的最小花费
-
递推公式：dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
- 可以从下标 i - 1 花费 cost[i - 1] 到达 i
- 可以从下边 i - 2 花费 cost[i - 2] 到达 i
- 为了使总花费最小，选择两个方案花费最小的
-
初始化：dp[0] =0; dp[1] = 0; 到达第0阶和第1阶不需要耗费体力，往上跳会耗费体力
-
遍历顺序：从前往后
代码
class Solution {
public:
/*
* dp[i]表示走到第i阶楼梯的最小花费
* 递推公式：dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
* 初始化：dp[0] = cost[0]; dp[1] = 0;
* 遍历顺序：从前往后
*/
int minCostClimbingStairs(vector& cost) {
vector dp(cost.size() + 1);
dp[0] = 0;
dp[1] = 0;
for (int i=2; i <= cost.size(); i++) {
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[cost.size()];
}
};
- 时间复杂度
O(n) - 空间复杂度
O(n)
优化
class Solution {
public:
/*
* dp[i]表示走到第i阶楼梯的最小花费
* 递推公式：dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
* 初始化：dp[0] = 0; dp[1] = 0;
* 遍历顺序：从前往后
*/
int minCostClimbingStairs(vector& cost) {
int dp0 = 0;
int dp1 = 0;
for (int i=2; i <= cost.size(); i++) {
int dp2 = min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
dp0 = dp1;
dp1 = dp2;
}
return dp1;
}
};
- 时间复杂度
O(n) - 空间复杂度
O(1)