剑指 Offer 10- I. 斐波那契数列
题目描述
写一个函数,输入 n ,求斐波那契(Fibonacci)数列的第 n 项(即 F(N))。斐波那契数列的定义如下:
- F(0) = 0, F(1) = 1
- F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
递归
直接如下使用“暴力递归”时,会“超时”
class Solution {
final int MOD = (int)(1e9 + 7);
public int fib(int n) {
if (n < 2) return n;
return (fib(n - 1) + fib(n - 2)) % MOD;
}
}
记忆化搜
直接使用“暴力递归”会包含很多 “重复性”的计算,影响了计算性能。
我们可以使用“记忆化搜”进行改善:
- 即 使用“记忆集”保存之前已经通过递归计算过结果的状态值;
- 下次递归前进行检查,若本次需要计算的结果已经在之前计算过,则直接从“记忆集”中 取出即可,不必在重复进行递归计算。
class Solution {
final int MOD = (int)(1e9 + 7);
int[] cache = new int[101];
public int fib(int n) {
if (n < 2) return n;
// 递归前,进行“记忆”检查
if (cache[n] != 0) {
return cache[n];
}
int res = (fib(n - 1) + fib(n - 2)) % MOD;
// 保存本次“记忆”
cache[n] = res;
return res;
}
}
dp
思路:简单dp
class Solution {
public int fib(int n) {
if (n < 2) return n;
int[] dp = new int[n + 1]; // dp[i] 表示第i个斐波那契数
// 3、初始化
dp[0] = 0;
dp[1] = 1;
// 4、遍历顺序
for (int i = 2; i <= n; i++) {
// 2、递推公式
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
}
// 5、打印dp
// System.out.println(Arrays.toString(dp));
return dp[n];
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度: O ( n ) O(n) O(n)
DP 优化空间
⭐️
-
在如上版本 DP 中,尽管
dp
数组长度为 n + 1 n + 1 n+1,但是每次进行状态转移时 其实只会用到当前位置的前两个状态。 -
所以,仅仅使用三个变量,即长度为 3 3 3 的
dp
数组即可。此时可以将 空间复杂度降为 O ( 1 ) O(1) O(1)。
class Solution {
public int fib(int n) {
if (n < 2) return n;
final int MOD = (int)(1e9 + 7);
int[] dp = new int[3];
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[2] = (dp[0] + dp[1]) % MOD;
dp[0] = dp[1];
dp[1] = dp[2];
}
System.out.println(Arrays.toString(dp));
return dp[2];
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度: O ( 1 ) O(1) O(1)
剑指 Offer 10- II. 青蛙跳台阶问题
题目描述
一只青蛙一次可以跳上1级台阶,也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
dp
思路:和 剑指 Offer 10- I. 斐波那契数列 基本一样。这里只使用了 DP 解法。
class Solution {
final int MOD = (int)(1e9 + 7);
public int numWays(int n) {
if (n < 2) return 1;
int[] dp = new int[n + 1]; // dp[i] 表示第i个斐波那契数
// 3、初始化
dp[0] = 1;
dp[1] = 1;
// 4、遍历顺序
for (int i = 2; i <= n; i++) {
// 2、递推公式
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
// 5、打印dp
// System.out.println(Arrays.toString(dp));
return dp[n];
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度:
O
(
n
)
O(n)
O(n)
剑指 Offer 63. 股票的最大利润
题目描述
假设把某股票的价格按照时间先后顺序存储在数组中,请问买卖该股票一次可能获得的最大利润是多少?
限制:
- 0 < = 数 组 长 度 < = 1 0 5 0 <= 数组长度 <= 10^5 0<=数组长度<=105
暴力
思路:题目相当于按顺序找一个差值最大的 元素对。数据量为 1 0 5 10^5 105,可以用 2 层 for 暴力求解。
class Solution {
public int maxProfit(int[] prices) {
int res = 0;
int n = prices.length;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (prices[j] > prices[i]) {
res = Math.max(res, prices[j] - prices[i]);
}
}
}
return res;
}
}
- 时间复杂度: O ( n 2 ) O(n^2) O(n2)
- 空间复杂度: O ( 1 ) O(1) O(1)
贪心 ⭐️
思路:
- 以最低价格买入,买入价格记作
minPrice
,若当前 p r i c e s [ i ] < m i n P r i c e prices[i] < minPrice prices[i]<minPrice,则更新minPrice
;(保证买入价格最低) - 每次将当前价格和 至今为止的最低价格
minPrice
作比较。若当前盈利更高,则“尝试”完成一次股票买卖。
class Solution {
public int maxProfit(int[] prices) {
int res = 0;
int n = prices.length;
int minPrice = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
if (prices[i] < minPrice) { // 更新最低价格
minPrice = prices[i];
} else { // “尝试”买入
res = Math.max(res, prices[i] - minPrice);
}
}
return res;
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度:
O
(
1
)
O(1)
O(1)
dp ⭐️
参考:Carl 题解
思路:
- 每天有2个状态:“持有”股票、卖出股票;
- d p [ i ] [ 0 ] dp[i][0] dp[i][0]:第 i i i 天“持有”股票的最大利润
- d p [ i ] [ 1 ] dp[i][1] dp[i][1]:第 i i i 天“卖出”股票的最大利润
- 递推公式
dp[i][0]
,即第 i i i 天“持有”股票的最大利润可能由两个状态推导而来:即,第 i − 1 i-1 i−1 天“持有”股票最大利润 或者 第 i i i 天买入的股价。即,dp[i][0] = Math.max(-prices[i], dp[i - 1][0]);
dp[i][1]
,即第 i i i 天“卖出“股票的最大利润也可能由两个状态推导而来:即,第 i − 1 i-1 i−1 天“卖出”的最大利润 和 第 i i i 天卖出的最大利润的 max。即,dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
- 初始化
- d p [ 0 ] [ 0 ] = − p r i c e s [ 0 ] ; dp[0][0] = -prices[0]; dp[0][0]=−prices[0];
- d p [ 0 ] [ 1 ] = 0 ; dp[0][1] = 0; dp[0][1]=0;
class Solution {
public int maxProfit(int[] prices) {
if (prices.length == 0) {
return 0;
}
int n = prices.length;
// 每天有2个状态:“持有”股票、卖出股票
int[][] dp = new int[n][2]; // dp[i][0]:第i天“持有”股票的最大利润
// dp[i][1]:第i天“卖出”股票的最大利润
// 3、初始化
dp[0][0] = -prices[0];
dp[0][1] = 0;
// 4、遍历顺序(由地推公式可知,从前到后)
for (int i = 1; i < n; i++) {
// 2、递推公式
dp[i][0] = Math.max(-prices[i], dp[i - 1][0]); // 第i天“持有”股票的最大利润可能为 第i-1天“持有”股票最大利润 或者 第i天买入的股价
dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]); // 第i天卖出股票的最大利润可能是第i-1天“卖出”的最大利润 和 第i天卖出的最大利润的 max
}
// 5、打印dp
// for (int i = 0; i < n; i++) {
// System.out.println(Arrays.toString(dp[i]));
// }
return dp[n - 1][1];
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度:
O
(
n
)
O(n)
O(n)