LeetCode买卖股票问题集合（六种股票问题）

一、买卖股票的最佳时机（LeetCode 121）

简单的动态规划问题，只能完成一次买卖，定义二维 dp[i] [] 数组，dp [i] [0]表示没有股票的状态，dp [i] [1]表示持有股票的状态，由于只能买卖一次股票所以 dp [i] [1]不受dp [i-1] [0]的影响

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

由于dp[i] [0] 只受 dp[i-1] [0] 和 dp[i-1] [1] 的影响，dp[i] [1] 只受 dp[i-1] [1] 的影响，所以可以化为一维数组对代码进行优化

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

二、买卖股票的最佳时机II （LeetCode 122）

可以完成多次买卖，但是不能同时进行多笔交易，需要卖出后才能再次买入。

与上一题121相比，区别在于dp[i] [1] 受 dp[i-1] [0] 的影响，保证买入前先卖出

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

由于dp[i] [0] 只受 dp[i-1] [0] 和 dp[i-1] [1] 的影响，dp[i] [1] 只受 dp[i-1] [1] 的影响，所以可以化为一维数组对代码进行优化

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

三、买卖股票的最佳时机 III（LeetCode 123）

最多可以完成两次买卖，但不能同时进行多笔交易，需要卖出后才能再次买入。

可以看出股票有四个状态：第一次买入buy1，第一次卖出sell1，第二次买入buy2，第二次卖出sell2。

第一次买入buy1 取决于在第i天时，未操作时买入的价格 和 前面买入的价格，不进行任何操作： buy1 = max(-prices[i],buy1)
第一次卖出sell1 取决于在第i天时，buy1加上卖出时的价格 和 卖出后，不进行任何操作：sell1 = max(buy1+prices[i],sell1)
第二次买入buy2 取决于在第i天时，sell1后减去买入的价格 和 买入后，不进行任何操作：buy2 = max(sell1-prices[i],buy2)
第二次卖出sell2 取决于在第i天时，buy2后加上卖出的价格 和 卖出后，不进行任何操作：sell2 = max(buy2+prices[i],sell2)

static int maxProfit(int[] prices) {int buy1 = -prices[0],sell1 = 0;int buy2 = -prices[0],sell2 = 0;for (int i = 0; i < prices.length; i++) {buy1 = Math.max(-prices[i],buy1);sell1 = Math.max(buy1 + prices[i],sell1);buy2 = Math.max(sell1 - prices[i],buy2);sell2 = Math.max(buy2 + prices[i],sell2);}return sell2;}

四、买卖股票的最佳时机 IV（LeetCode 188）

最多可以完成k次买卖，但不能同时进行多笔交易，需要卖出后才能再次买入。

可以用buy[i] [j] 和 sell[i] [j] 这两个二维数组来分别表示买入和卖出的状态，其中i表示第i天，j表示当前是第j次交易。

buy[i] [j] 可以由 在第i-1天持有股票，不做任何操作 和 在第i天买入股票决定（在第i天买入股票的状态是sell[i-1] [j]，表示在第i天前股票已经卖出）：buy[i] [j] = max(buy[i-1] [j] , sell[i-1] [j] + prices[i])
sell[i] [j] 可以由 在第i-1天卖出股票，不做任何操作 和 在第i天卖出股票决定 （在第i天卖出股票的状态是buy[i-1] [j-1]，表示在第i-1天前买入的股票，此时还是属于第j-1次交易）：sell[i] [j] = max(buy[i-1] [j-1] + prices[i] , sell[i-1] [j])

边界问题：

buy[0] [1…k] 和 sell[0] [1…k] 时，由于在第一天只有prices[0] 唯一的股价，不可能有任何交易，所以可以把他们设置成很小的值表示没有交易的状态。
buy[0] [0] 可以表示在第一天买入股票，则可以初始化：buy[0] [0] = -prices[0]
sell[0] [0] 可以表示在第一天不做任何操作，手上不持有股票，则可以舒适化：sell[0] [0] = 0

public int maxProfit(int k, int[] prices) {if (prices.length == 0) return 0;k = Math.min(k,prices.length/2);int[][] buy = new int[prices.length][k+1];int[][] sell = new int[prices.length][k+1];buy[0][0] = -prices[0];sell[0][0] = 0;for (int i = 1; i <= k; i++) {buy[0][i] = sell[0][i] = Integer.MIN_VALUE/2;}for (int i = 1; i < prices.length; i++) {buy[i][0] = Math.max(buy[i-1][0],sell[i-1][0]-prices[i]);for (int j = 1; j <= k; j++) {buy[i][j] = Math.max(buy[i-1][j],sell[i-1][j] - prices[i]);sell[i][j] = Math.max(buy[i-1][j-1] + prices[i],sell[i-1][j]);}}return Arrays.stream(sell[prices.length-1]).max().getAsInt();}

由状态转移方程可以看出buy[i] [j] 和 sell[i] [j] 都从buy[i-1] […]，sell[i-1] […]转移而来，所以我们可以用一维数组来进行优化

buy[j] = max( buy[j] , sell[j] - prices[i] )

sell[j] = max( buy[j-1] + prices[i] , sell[j] )

这里可以看到，由于buy[j] 先进行运算，得到的 buy[j] 覆盖了 buy[j] 原来的值，相当于二维数组中buy[i-1] [j-1] 被 buy[i] [j-1] 覆盖了，但结果其实没有影响。

由于 buy[j - 1] -> buy[i] [j-1] =  max( buy[i-1] [j-1] , sell[i-1] [j-1] - prices[i] )代入 sell[j] = max(sell[j] , buy[i-1] [j-1] + prices , sell[i-1] [j-1])

因为sell[i - 1] [j - 1] 表示的是在同一天内买入和卖出，不会带来额外收益，对答案不产生影响。

public int maxProfit(int k, int[] prices) {if (prices.length == 0) return 0;k = Math.min(k,prices.length/2);int[] buy = new int[k+1];int[] sell = new int[k+1];buy[0] = -prices[0];sell[0] = 0;for (int i = 1; i <= k; i++) {buy[i] = sell[i] = Integer.MIN_VALUE/2;}for (int i = 1; i < prices.length; i++) {buy[0] = Math.max(buy[0],sell[0]-prices[i]);for (int j = 1; j <= k; j++) {buy[j] = Math.max(buy[j],sell[j] - prices[i]);sell[j] = Math.max(buy[j-1] + prices[i],sell[j]);}}return Arrays.stream(sell).max().getAsInt();}

五、最佳买卖股票时机含冷冻期（LeetCode 309）

可以完成多次买卖，但不能同时进行多笔交易，需要卖出后才能再次买入，卖出后有一天的冷冻期，不能买入。

可以定义一个dp[] []二维数组

dp[i] [0]表示: 手上持有股票的最大收益
dp[i] [1]表示: 手上不持有股票，并且处于冷冻期中的累计最大收益
dp[i] [2]表示: 手上不持有股票，并且不在冷冻期中的累计最大收益

由此可以推出状态方程

dp[i] [0] 可以由 在第 i-1天持有股票，不做任何操作和在第i天购买股票，且不处于冷冻期 决定：dp[i] [0] = max(dp[i-1] [0],dp[i-1] [2])
dp[i] [1] 可以由 在第 i-1天卖出股票 决定：dp[i] [1] = dp[i-1] [0] + prices[i]
dp[i] [2] 可以由 在第 i-1天不持有股票，且处于冷冻期 和 在第 i-1天不持有股票，且不处于冷冻期 决定：dp[i] [2] = max(dp[i-1] [1],dp[i-1] [2])

边界条件：dp[0] [0] = -prices[0] 表示在第一天买入。dp[0] [1] 和 dp[0] [2] 表示在第一天不持有股票，则默认为0。

public int maxProfit(int[] prices) {if (prices.length == 0) return 0;int[][] dp = new int[prices.length][3];dp[0][0] = -prices[0];for (int i = 1; i < prices.length; i++) {// dp[i][0]: 手上持有股票的最大收益// dp[i][1]: 手上不持有股票，并且处于冷冻期中的累计最大收益// dp[i][2]: 手上不持有股票，并且不在冷冻期中的累计最大收益dp[i][0] = Math.max(dp[i-1][0],dp[i-1][2] - prices[i]);dp[i][1] = dp[i-1][0] + prices[i];dp[i][2] = Math.max(dp[i-1][1],dp[i-1][2]);}return Math.max(dp[prices.length-1][1],dp[prices.length-1][2]);}

由上可以看出 dp[i] […] 都由 dp[i-1] […] 推导出来，所以可以设置三个变量对代码进行优化

static int maxProfit(int[] prices) {if (prices.length == 0) return 0;//dp0 表示第i-1天，手上持有股票的最大收益//dp1 表示第i-1天，手上不持有股票，处于冷冻期的累计最大收益//dp2 表示第i-1天，手上不持有股票，不处于冷冻期的累计最大收益int dp0 = -prices[0];int dp1 = 0, dp2 = 0;for (int i = 1; i < prices.length; i++) {int newdp0 = Math.max(dp0,dp2-prices[i]);int newdp1 = dp0 + prices[i];int newdp2 = Math.max(dp1,dp2);dp0 = newdp0;dp1 = newdp1;dp2 = newdp2;}return Math.max(dp1,dp2);}

六、买卖股票的最佳时机含手续费（LeetCode 714）

可以完成多次买卖，但是不能同时进行多笔交易，需要卖出后才能再次买入，卖出时需要手续费。

与买卖股票的最佳时机II 很相似，只是多了手续费的条件

定义一个dp[] [] 二维数组，dp [i] [0]表示没有股票的状态，dp [i] [1]表示持有股票的状态

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

由于dp[i] [0] 和 dp[i] [1] 只受 dp[i-1] [0] 和 dp[i-1] [1] 的影响，所以可以设置常量对代码进行优化

    static int maxProfit(int[] prices,int fee) {int buy = -prices[0],sell = 0;for (int i = 1; i < prices.length; i++) {buy = Math.max(buy,sell - prices[i]);sell = Math.max(buy + prices[i] - fee,sell);}return sell;}