LeetCode买卖股票的最佳时机系列总结

LeetCode买卖股票的最佳时机系列总结

此类动态规划从二维动规理解后优化到一维动规，部分题目还可以用到贪心。

目录：

121 买卖股票的最佳时机1
122 买卖股票的最佳时机2
123 买卖股票的最佳时机3
188 买卖股票的最佳时机4
309 买卖股票的最佳时机+冷冻期
714 买卖股票的最佳时机+手续费（2的基础上卖出时-手续费）

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 maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n == 1)return 0;
        vector<vector<int>>dp(n, vector<int>(2));
        dp[0][0] = 0;                 // 不持有 = 卖出+还没买
        dp[0][1] = -prices[0];        // 持有 买过还没卖
        for(int i = 1; i < n; ++i) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            //第i天不持有 = max(第i - 1不持有, i - 1天持有+今天卖出)
            dp[i][1] = max(dp[i - 1][1],  -prices[i]);
            //第i天持有 = max(第i - 1持有, 今天买入，只买一次)
        }
        return dp[n - 1][0];
    }

一维动规O(N)/O(1)
每一天的状态只与前一天的状态有关，把dp[i - 1][1],dp[i - 1][0]存在两个变量中，
计算出dp[i][1],dp[i][0]在存回对应变量即可
int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n == 1)return 0;
        int sell = 0;                // 不持有 = 卖出+还没买
        int buy = -prices[0];        // 持有 买过还没卖
        for(int i = 0; i < n; ++i) {
            int newbuy = max(buy, -prices[i]);
            int newsell = max(sell, buy + prices[i]);
            sell = newsell;
            buy = newbuy;
        }
        return sell;
    }

贪心：
int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n == 1)return 0;
        int maxn = 0;
        int start = prices[0];
        for(int i = 1; i < n; ++i) {
            if(prices[i] < start) start = prices[i];
            //下一个小于假设买入的价格，更新start
            else maxn = max(maxn, prices[i] - start);
            //更新最大利润
        }
        return maxn;
    }

122 买卖股票的最佳时机2 （买卖多次）

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

二维动规
定义状态dp[i][1] 表示第i天交易完后手里没有股票的最大利润，
dp[i][0] 表示第i天交易完后手里持有一支股票的最大利润（i从0开始）。
 int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>>dp(n, vector<int>(2));
        dp[0][0] = - prices[0];  //持有
        dp[0][1] = 0;            //未持有
        for(int i = 1; i < n; ++i) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
             //第i天持有 = max(第i - 1持有, i - 1天不持有今天买入)和1不同
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[n - 1][1];
    }
};

一维动规
int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp0 = -prices[0];
        int dp1 = 0;
        for(int i = 1; i < n; ++i) {
            int newdp0 = max(dp0, dp1 - prices[i]);
            int newdp1 = max(dp1, dp0 + prices[i]);
            dp0 = newdp0;
            dp1 = newdp1;
        }
        return dp1;
    }

贪心，收集所有上坡，和是最大
 int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int maxn = 0;
        for(int i = 1; i < n; ++i) maxn += max(0, prices[i] - prices[i - 1]);
        return maxn;
    }

123 买卖股票最佳时机 （买卖2次）

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
思路：买两次状态有：无操作，第一次买入，第一次卖出，第二次买入，第二次卖出。

二维动规
 int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n <= 1)return 0;
        vector<vector<int>>dp(n, vector<int>(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 < n; ++i) {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
            //第一次买入 = max(前一天无操作今天买入， 前一天已经买入)
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            //第一次卖出 = max(前一天已经卖出， 前一天买入今天卖出)
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            //第二次买入 = max(前一天已经第二次买入，前一天是第一次卖出+今天买入)
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
            //第二次卖出 = max(前一天已经第二次买入。前一天是第二次买入+今天卖出)
        }
        return dp[n - 1][4];
    }

 一维动规；每一天的状态只与前一天的状态有关
 int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if(n <= 1)return 0;
        int buy1 = -prices[0];
        int sell1 = 0;
        int buy2 = -prices[0];
        int sell2 = 0;
        for(int i = 1; i < n; ++i) {
            buy1 = max(buy1, -prices[i]);
            sell1 = max(sell1, buy1 + prices[i]);
            buy2 = max(buy2, sell1 - prices[i]);
            sell2 = max(sell2, buy2 + prices[i]);
        }
        return sell2;
    }

188买卖股票最佳时机 (买卖k次)

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

二维动规
 int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        if(k == 0 || n == 0)return 0;
        vector<vector<int>>dp(n, vector<int>(2*k + 1, 0));
        for(int i = 1; i < 2*k; i += 2) dp[0][i] = -prices[0]; //奇数买入
        for(int i = 1; i < n; i++) {
            for(int j = 0; j < 2*k - 1; j += 2) {
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] -prices[i]);
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[n - 1][2*k];
    }

309 买卖股票的最佳时机+冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

二维动规
 int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>>dp(n, vector<int>(3));
        dp[0][0] = -prices[0];   //持有
        dp[0][1] = 0;            //不持有，在冷冻
        dp[0][2] = 0;            //不持有，不在冷冻
        for(int i = 1; i < n; ++i) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][2] - prices[i]);
            //第i天持有 = max(i - 1天持有， i - 1天不持有不在冷冻 今天买入)
            dp[i][1] = dp[i - 1][0] + prices[i];
            //第i天不持有在冷冻 = i - 1刚卖出
            dp[i][2] = max(dp[i - 1][2],dp[i - 1][1]);
            //第i天不持有不冷冻 = max(i - 1天不持有不冷冻， i - 1天冷冻)
        }
        return max(dp[n - 1][1], dp[n - 1][2]);
    }

一维，空间优化
int maxProfit(vector<int>& prices) {
    int n = prices.size();
    int buy = -prices[0], sell = 0, lock = 0;
    //持有不持有，在冷冻//不持有，不在冷冻
    for(int i = 0; i < n; i++) {
        int newbuy = max(buy, lock - prices[i]);
        int newsell = buy + prices[i];
        int newlock = max(lock, sell);
        buy = newbuy;
        sell = newsell;
        lock = newlock;
    }
    return max(lock, sell);
}