代码随想录-动态规划-买卖股票问题

买卖股票问题

T121-买卖股票的最佳时机

见LeetCode第121题[买卖股票的最佳时机]

题目描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。

设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例

输入：[7,1,5,3,6,4] 
输出：5 
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

我的思路

• 定义int[] dp，dp[i]表示第i天最大利润，而min表示第i天之前的最低点
• 对于第i天的操作
  • 卖出：dp[i] = prices[i] - min
  • 不卖：dp[i] = dp[i - 1]
• 如何进行抉择？怎么判断是该卖还是不卖？
  • dp[i] = Math.max(prices[i] - min, dp[i - 1])
  • min的更新：min = Math.min(min, prices[i])

public int maxProfit(int[] prices) {
    if (prices.length <= 1) return 0;
    int n = prices.length;
    // 初始化 dp 数组，其中第 0 天和第 1 天的利润都是 0
    int[] dp = new int[n + 1];

    // 记录当前天的最低点
    int min = prices[0];

    // 从第 2 天开始计算出利润
    for (int i = 2; i <= n; i++) {
        min = Math.min(min, prices[i - 1]);
        dp[i] = Math.max(
                prices[i - 1] - min, // 卖出
                dp[i - 1] // 不卖出
        );
    }
    return dp[n];
}

计算复杂度分析

• 时间复杂度：$O(N)$
• 空间复杂度：$O(N)$

优化思路

可以将dp[]数组使用一个变量dp存储

public int maxProfitII(int[] prices) {
    if (prices.length <= 1) return 0;
    int n = prices.length;
    int min = prices[0];
    int dp = 0;

    for (int price : prices) {
        min = Math.min(price, min);
        dp = Math.max(dp, price - min);
    }
    return dp;
}

T122-买卖股票的最佳时机II

见LeetCode第122题[买卖股票的最佳时机II]

题目描述

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例

输入： prices = [7,1,5,3,6,4]
输出： 7
解释： 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
最大总利润为 4 + 3 = 7 。

我的思路

• 相较于上一题，这一题开放了买卖的限制，即可以进行多次买进卖出
• 如何保证利润最大化？我们在每次的波谷买入，在波峰卖出即可，即寻找局部最大值和最小值
• 可以使用快慢指针
  • 慢指针只停留在波谷标记买入时刻
  • 快指针需要寻找波峰值和波谷，并标记波峰，卖出

/**
 * 买卖股票的最佳时机II
 * @param prices
 * @return
 */
public int maxProfit(int[] prices) {
    if (prices.length <= 1) return 0;
    int maxProfit = 0;

    // 初始化快慢指针
    int slow = 0;
    int fast = 1;

    while (fast < prices.length) {
        // 先寻找最低点
        while (fast < prices.length && prices[fast] <= prices[fast - 1]) fast++;
        // 根据fast位置判断是否是单调递减，如果单调递减，直接返回 maxProfit
        if (fast == prices.length) return maxProfit;
        else slow = fast - 1;
        // 寻找最高点
        while (fast < prices.length && prices[fast] >= prices[fast - 1]) fast++;
        // 直接将 fast 之前的索引记为波峰
        maxProfit += prices[fast - 1] - prices[slow];
    }
    return maxProfit;
}

计算复杂度分析

• 时间复杂度：$O(N)$，遍历了一遍prices数组
• 空间复杂度：$O(1)$，常数级变量用来存储快慢指针

T123-买卖股票的最佳时机III

见LeetCode第123题[买卖股票的最佳时机III]

题目描述

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：prices = [3,3,5,0,0,3,1,4] 
输出：6 
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，
这笔交易所能获得利润 = 3-0 = 3 。 
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，
这笔交易所能获得利润 = 4-1 = 3 。

我的思路

没有思路

题解思路

• 动态规划三要素：状态转移方程、最佳子结构、重复子问题
• 首先是状态，对于第i天的状态有什么？
  • 没有进行任何操作dp[i][0]
  • 进行了第一次买入操作dp[i][1]
  • 进行了第一次完整的买卖操作dp[i][2]
  • 进行了第二次买入操作dp[i][3]
  • 完成两次买卖操作dp[i][4]
• 状态是如何进行转移的？
• 一直不买：dp[i][0] = 0
• dp[i][1]
  • 买不买入的问题：dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - price[i])
  • 如果买入，则利润为dp[i - 1][0] - price[i]
  • 如果不买入，则利润为dp[i - 1][1]
• dp[i][2]：卖不卖出的问题
  • 如果卖出，则利润为：dp[i - 1][1] + price[i]
  • 如果不卖，则利润为dp[i - 1][2]
• dp[i][3]：买不买入的问题
  • 如果买入，则利润为dp[i - 1][2] - price[i]
  • 如果不买，则利润为dp[i - 1][3]
• dp[i][4]：卖不卖出的问题
  • 如果卖出，则利润为：dp[i - 1][3] + price[i]
  • 如果不卖，则利润为dp[i - 1][4]

初始化状态是什么？

• dp[0][0] = 0
• dp[0][1] = -price[0]
• dp[0][2] = 0
• dp[0][3] = -price[0]
• dp[0][4] = 0

public int maxProfit(int[] prices) {
    if (prices.length <= 1) return 0;

    // 初始化 dp 数组
    int[][] dp = new int[prices.length][5];
    dp[0][0] = 0;
    dp[0][1] = -prices[0];
    dp[0][2] = 0;
    dp[0][3] = -prices[0];
    dp[0][4] = 0;

    for (int i = 1; i < prices.length; i++) {
        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
        dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
        dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
    }
    return dp[prices.length - 1][4];
}

计算复杂度分析

• 时间复杂度：$O(N)$
• 空间复杂度：$O(N)$

优化思路

可以将二维dp数组压缩到一维dp，节省空间，提升效率

T188-买卖股票的最佳时机IV

见LeetCode第188题[买卖股票的最佳时机IV]

题目描述

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1] 
输出：2 
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，
这笔交易所能获得利润 = 4-2 = 2 。

我的思路

• 本题是第123题[买卖股票的最佳时机III]更加一般的形式，但是换汤不换药，两次和k次的区别
• 同样地，可以分别定义两个int[] dp表示买入和卖出的最大利润

public int maxProfit(int k, int[] prices) {

    if (prices.length <= 1) return 0;

    // 初始化 dp 数组
    int[] buy = new int[k];
    int[] sell = new int[k];
    Arrays.fill(buy, -prices[0]);

    for (int i = 1; i < prices.length; i++) {
        buy[0] = Math.max(buy[0], -prices[i]); // 第一次买入
        sell[0] = Math.max(sell[0], buy[0] + prices[i]); // 第一次卖出
        for (int j = 1; j < k; j++) {
            // 状态转移的时候应该是 截止前一个交易日 时交易 k 次最大利润
            // 而不应该是，截止到前一个交易日时，交易 k - 1 次最大利润
            buy[j] = Math.max(sell[j - 1] - prices[i], buy[j]);
            sell[j] = Math.max(buy[j] + prices[i], sell[j]); //
        }
    }
    return sell[k - 1];
}

计算复杂度分析

• 时间复杂度：$O(K\times N)$
• 空间复杂度：$O(K)$

T309-买卖股票的最佳时机「含冷冻期」

见LeetCode第309题[买卖股票的最佳时机「含冷冻期」]

题目描述

给定一个整数数组prices，其中第 prices[i] 表示第 i天的股票价格 。

• 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [1,2,3,0,2] 
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

我的思路

• 三个数组int[] buy，int[] sell，int[] freeze表示在i为三种状态下的最大利润
• 如何去更新这三种状态？

(1)i为buy，当天买进

那么今天买进的最大利润为：

• 买的话：昨天冷冻期的利润 减去 今天的价格：freeze[i - 1] - prices[i]
• 不买：昨天买的利润 buy[i - 1]
• 更新方程为：buy[i] = Math.max(buy[i - 1], freeze[i - 1] - prices[i])

（2）当天可以自由卖出

• 卖的话：昨天买入的利润 加上 今天的价格：buy[i - 1] + prices[i]
• 不卖：昨天卖的利润 sell[i- 1]
• 更新方程为：sell[i] = Math.max(sell[i - 1], buy[i - 1] + prices[i])

（3）当天是冷冻期

• 不能进行买卖，冷冻期的利润为上一次卖出的利润
• 更新方程为：freeze[i] = sell[i - 1]

/**
 * 带有冷冻期的最大利润
 * @param prices
 * @return
 */
public int maxProfit(int[] prices) {
    if (prices == null || prices.length <= 1) return 0;
    int n = prices.length;
    // 分别初始化 买入、卖出、冷冻期 的数组
    int[] buy = new int[n];
    Arrays.fill(buy, -prices[0]);
    int[] sell = new int[n];
    int[] freeze = new int[n];

    for (int i = 1; i < n; i++) {
        // 买入的利润
        buy[i] = Math.max(buy[i - 1], freeze[i - 1] - prices[i]);

        // 卖出的利润
        sell[i] = Math.max(sell[i - 1], buy[i - 1] + prices[i]);

        // 冷冻期的利润
        freeze[i] = sell[i - 1];
    }

    return sell[n - 1];
}

计算复杂度分析

• 时间复杂度：$O(N)$
• 空间复杂度：$O(N)$

T714-买卖股票最佳时机-含手续费

见LeetCode第714题[买卖股票最佳时机-含手续费]

题目描述

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意： 这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入： prices = [1, 3, 2, 8, 4, 9], fee = 2
输出： 8
解释： 能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

我的思路

• 初始化两个数组int[] buy和int[] sell表示当前日买入或者卖出的最大利润
• 在考虑卖出的时候，需要将当前的利润减去手续费，即buy[i - 1] + prices[i] - fee

/**
 * 有手续费的情况下，买卖股票的最大利润
 * @param prices
 * @param fee
 * @return
 */
public int maxProfit(int[] prices, int fee) {
    if (prices.length <= 1) return 0;
    int n = prices.length;

    // 分别初始化 buy[] 和 sell[] 数组，表示当前天买入或者卖出能够获取的最大利润
    int[] buy = new int[n];
    buy[0] = -prices[0];
    int[] sell = new int[n];

    // 更新 buy[] 和 sell[]
    for (int i = 1; i < n; i++) {

        // 更新 buy[]
        buy[i] = Math.max(
                buy[i - 1], // 今日不买入股票
                sell[i - 1] - prices[i] // 今日买入
        );

        // 更新卖出利润，需要添加手续费
        sell[i] = Math.max(
                sell[i - 1], // 今日不卖出
                buy[i - 1] + prices[i] - fee
        );
    }

    return sell[n - 1];
}

计算复杂度分析

• 时间复杂度：$O(N)$，需要遍历一遍prices[]数组去更新buy和sell
• 空间复杂度：$O(N)$，存储buy和sell，当然，可以将其压缩为$O(1)$的数组