leetcode股票系列

121. 买卖股票的最佳时机

题目
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

示例 1:

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

这道题很简单，只要找到两个数之间的最大正间隔即可。一次遍历，找到每个数和之前最小值的差值，最大的差值即为答案。

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length==0){
            return 0;
        }
        int min=prices[0];
        int ans=0;
        for(int p:prices){
            ans=ans>p-min?ans:p-min;
            min=p>min?min:p;
        }
        return ans;
    }
}

122. 买卖股票的最佳时机 II

题目
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

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

示例 1:

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

这里有两点：

1. 股票的买卖一定是上坡状态
2. 1->5 + 3->6 的这样的收入一定大于 1->6

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

123. 买卖股票的最佳时机 III

题目
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

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

示例 1:

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

这里的难度主要是规定了只能有两次买卖，所以不可以直接按照II中的方法，找出间隔最大的两个直接相加。例如，[1,2,4,2,5,7,2,4,9,0]，按照II中做法，找到三个gap是3,5,7，如果直接选出5+7=12是错误的，因为如果从1买入，7卖出，是6，单个的6要大于3/5，正确答案应该是6+7=13

正确解法：dp。
每一天都处于两种状态：

1. 当前位于第几次交易（i）
2. 当前交易是要买入还是卖出（j=0:买入；j=1:卖出）

这一题是下面一题的子题，这里的动态规划方程主要来自于下面一题，可参考下面最多可完成k比交易的题目解法。

class Solution {
    public int maxProfit(int[] prices) {
        // dp[i][j]：第i次交易;j=0:买入；j=1:卖出
        int[][] dp=new int[2][2];
        dp[0][0]=dp[1][0]=Integer.MIN_VALUE;
        for(int p:prices){
            dp[0][0]=Math.max(dp[0][0],-p);
            dp[0][1]=Math.max(dp[0][1],dp[0][0]+p);
            dp[1][0]=Math.max(dp[1][0],dp[0][1]-p);
            dp[1][1]=Math.max(dp[1][1],dp[1][0]+p);
        }
        return dp[1][1];
    }
}

简化上面二维数组。

class Solution {
    public int maxProfit(int[] prices) {
        /**
        对于任意一天考虑四个变量:
        fstBuy: 在该天第一次买入股票可获得的最大收益 
        fstSell: 在该天第一次卖出股票可获得的最大收益
        secBuy: 在该天第二次买入股票可获得的最大收益
        secSell: 在该天第二次卖出股票可获得的最大收益
        分别对四个变量进行相应的更新, 最后secSell就是最大
        收益值(secSell >= fstSell)
        **/
        int fstBuy = Integer.MIN_VALUE, fstSell = 0;
        int secBuy = Integer.MIN_VALUE, secSell = 0;
        for(int p : prices) {
            fstBuy = Math.max(fstBuy, -p);
            fstSell = Math.max(fstSell, fstBuy + p);
            secBuy = Math.max(secBuy, fstSell - p);
            secSell = Math.max(secSell, secBuy + p); 
        }
        return secSell;
    }
}

188. 买卖股票的最佳时机 IV

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

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

题目
很多题解都不太能理解，这篇是很好理解的题解

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n=prices.size();
        if(k<1 || n<1){
            return 0;
        }
        if(k>n/2){
            return maxProfitInfinite(prices);
        }

        int dp[10010][2];
        for(int i=0;i<k;i++){
            dp[i][0]=-2147483648;dp[i][1]=0;
        }

        for(int p:prices){
            dp[0][0]=max(dp[0][0],-p);
            dp[0][1]=max(dp[0][1],dp[0][0]+p);

            for(int i=1;i<k;i++){
                dp[i][0]=max(dp[i-1][1]-p,dp[i][0]);
                dp[i][1]=max(dp[i][0]+p,dp[i][1]);
            }
        }

        return dp[k-1][1];
    }

    int maxProfitInfinite(vector<int>& prices){
        int maxprofit=0;
        for(int i=0;i<prices.size()-1;i++){
            if(prices[i]<prices[i+1]){
                maxprofit+=(prices[i+1]-prices[i]);
            }
        }
        return maxprofit;
    }
};

309. 最佳买卖股票时机含冷冻期

题目
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:

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

题解
这个真的好难想到，希望下次看时能有新的感悟

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.empty()) {
            return 0;
        }

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