算法——买卖股票

最新推荐文章于 2025-12-02 15:32:05 发布

原创最新推荐文章于 2025-12-02 15:32:05 发布 · 363 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #java #贪心算法 #动态规划

买卖股票的状态

dp[i][k][0 or 1]
0 <= i <= n - 1, 1 <= k <= K
n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。
此问题共 n × K × 2 种状态，全部穷举就能搞定。

for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
            dp[i][k][s] = max(buy, sell, rest)

这个问题的「状态」有三个：
第一个是天数
第二个是允许交易的最大次数
第三个是当前的持有状态（用 1 表示持有，0 表示没有持有）

状态转移

今天我没有持有股票，有两种可能，我从这两种可能中求最大利润：

1、我昨天就没有持有，且截至昨天最大交易次数限制为 k；然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。
2、我昨天持有股票，且截至昨天最大交易次数限制为 k；但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max( 今天选择 rest,        今天选择 sell       )

今天我持有着股票，最大交易次数限制为 `k`，那么对于昨天来说，有两种可能，我从这两种可能中求最大利润

1、我昨天就持有着股票，且截至昨天最大交易次数限制为 k；然后今天选择 rest，所以我今天还持有着股票，最大交易次数限制依然为 k。
2、我昨天本没有持有，且截至昨天最大交易次数限制为 k - 1；但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max( 今天选择 rest,         今天选择 buy         )

K的定义

时刻牢记「状态」的定义，状态 k 的定义并不是「已进行的交易次数」，而是「最大交易次数的上限限制」。
如果确定今天进行一次交易，且要保证截至今天最大交易次数上限为 k，那么昨天的最大交易次数上限必须是 k - 1

base case

dp[-1][...][0] = 0 解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0。


dp[-1][...][1] = -infinity 解释：还没开始的时候，是不可能持有股票的。因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。


dp[...][0][0] = 0 解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0。


dp[...][0][1] = -infinity 解释：不允许交易的情况下，是不可能持有股票的。因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。

分类

一次买卖k=1

（1）动态规划：


class Solution {
    public int maxProfit(int[] prices) {
        int n=prices.length;
        if(prices==null||n==0)return 0;
        int[][]dp = new int[n][2];
        //base case
        dp[0][0]=0;
        dp[0][1]=-prices[0];
        for(int i=1;i<n;i++){
            dp[i][0] = Math.max(dp[i-1][1]+prices[i],dp[i-1][0]);
            dp[i][1]=Math.max(dp[i-1][1],-prices[i]);//！！！！！注意这里，因为只有一次买入的机会，所以这唯一一次买入之前的利润绝对是0
        }
        return dp[n-1][0];
    }
}

（2）【贪心】思路：只要找到最低点买入、最高点卖出：

class Solution {
    public int maxProfit(int[] prices) {
        int minPrice=Integer.MAX_VALUE;
        int maxProfitRes = 0;
        for(int p:prices){
            minPrice=Math.min(minPrice,p);
            maxProfitRes=Math.max(maxProfitRes,p-minPrice);
        }
        return maxProfitRes;
    }
}

K无限次

1.K=无限次，无其他限制

（1）动态规划

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

（2）【贪心】
因为交易次数不受限，只要股票 今天涨价了，我们就可以把差价赚到：

如果 prices[i] > prices[i-1]，就把 prices[i] - prices[i-1] 加到利润里。
因为这是在模拟“低买高卖”，等价于把所有上升区间的利润累加。
这样做的好处：
不用管买入和卖出的具体时机，因为所有上涨的部分我们都会赚到。

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int res = 0;
        for (int i = 1; i < n; i++) {
            if (prices[i] > prices[i-1]) {
                res += prices[i] - prices[i-1];
            }
        }
        return res;
    }
}

2.k 为正无穷，但含有交易冷冻期（有第三个状态参与到了状态转移）

为什么需要dp？

在“无限次交易”时，只要有涨幅就可以立刻卖掉，因为没有限制。
但这题有 冷冻期 1 天：
- 你卖出之后，第二天不能买入。
- 所以你不能只看今天涨没涨，还要看冷冻期的限制，带来未来决策的依赖。
贪心只看眼前，做不到全局最优 → 所以要用 DP。

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if (n == 0) return 0;

        int[][] dp = new int[n][3];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;

        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][2]);//今天 没有持股，并且 今天没卖股票（可能是休息）
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]);//今天 持股
            dp[i][2] = dp[i-1][1] + prices[i];//今天 没有持股，并且 今天刚卖掉股票
        }

        return Math.max(dp[n-1][0], dp[n-1][2]);
    }
}

3.k 为正无穷，但有手续费（based onK为正无穷无限制）

为什么用dp？

如果没有手续费，可以用贪心：每次有涨幅就卖出，累计所有正收益。
但有手续费后，卖股票的时机会影响总利润：
- 过早卖出 → 手续费扣太多 → 总利润低
- 太晚卖出 → 可能错过更大的涨幅
这就变成了一个 全局最优问题，不能用贪心，必须用 动态规划，让程序自动在所有可能的交易方案里找出最优解。

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int n = prices.length;
        if (n == 0) return 0;

        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

        for (int i = 1; i < n; 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][1], dp[i-1][0] - prices[i]);
        }

        return dp[n-1][0];
    }
}

K有限制【增加了一个状态】

为什么要有第三个维度

因为：

只用 dp[i][0/1] 时，无法限制交易次数。
第三维 k 记录了你还剩多少次交易机会，确保每次买入都会消耗一次交易。

注意：K为什么从后往前减小

K 倒序 = 保证每次买入都用昨天完成的交易数，而不是今天刚更新过的。

dp[i][k][0] → 第 i 天，最多允许 k 笔交易，手里 【没有】 股票 的最大利润
dp[i][k][1] → 第 i 天，最多允许 k 笔交易，手里 【有】 股票 的最大利润

K为某target

class Solution {
    public int maxProfit(int K, int[] prices) {
         int n = prices.length;
        if (n == 0) return 0;
        int[][][] dp = new int[n][K+1][2];
        // 初始化
        for (int k = 1; k <= K; k++) {
            dp[0][k][0] = 0;
            dp[0][k][1] = -prices[0];
        }

        for (int i = 1; i < n; i++) {
            for (int k = K; k >= 1; k--) {
                dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
                dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);//要在这天买入，前一天的最大交易次数就是k-1
            }
        }

        return dp[n-1][K][0];
    }
}