买卖股票的最佳时机

力扣：121. 买卖股票的最佳时机 - 力扣（LeetCode）
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1： 输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 示例 2： 输入： prices = [7,6,4,3,1]
输出： 0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
暴⼒
这道题⽬最直观的想法，就是暴⼒，找最优间距了。

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

时间复杂度：O(n^2)
空间复杂度：O(1)
不出意外该⽅法超时了。
贪⼼因为股票就买卖⼀次，那么贪⼼的想法很⾃然就是取最左最⼩值，取最右最⼤值，那么得到的差值就是最⼤利润。
Java代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        int max = 0;
        int x = prices[0];
        for(int i = 1; i < prices.length; i++){
            x = Math.min(x ,prices[i]);
            if(prices[i] > x)
                max = Math.max(max, prices[i] - x);
        } 
        return max;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

动规五部曲：

1. 确定dp数组以及下标的含义

dp[i][0] 表示第i天持有股票所得最多现⾦，这⾥可能有同学疑惑，本题中只能买卖⼀次，持有股票之后哪还有现⾦呢？
其实⼀开始现⾦是0，那么加⼊第i天买⼊股票现⾦就是 -prices[i]，这是⼀个负数。
dp[i][1] 表示第i天不持有股票所得最多现⾦
注意这⾥说的是“持有”，“持有”不代表就是当天“买⼊”！也有可能是昨天就买⼊了，今天保持持有的状态很多朋友把“持有”和“买⼊”没分区分清楚。
在下⾯递推公式分析中，我会进⼀步讲解。

2. 确定递推公式

如果第i天持有股票即dp[i][0]，那么可以由两个状态推出来
第i-1天就持有股票，那么就保持现状，所得现⾦就是昨天持有股票的所得现⾦即：dp[i - 1][0]
第i天买⼊股票，所得现⾦就是买⼊今天的股票后所得现⾦即：-prices[i]
那么dp[i][0]应该选所得现⾦最⼤的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);
如果第i天不持有股票即dp[i][1]，也可以由两个状态推出来
第i-1天就不持有股票，那么就保持现状，所得现⾦就是昨天不持有股票的所得现⾦即：dp[i - 1][1]
第i天卖出股票，所得现⾦就是按照今天股票佳价格卖出后所得现⾦即：prices[i] + dp[i - 1][0]
同样dp[i][1]取最⼤的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
这样递归公式我们就分析完了

3. dp数组如何初始化

由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
可以看出其基础都是要从dp[0][0]和dp[0][1]推导出来。那么dp[0][0]表示第0天持有股票，此时的持有股票就⼀定是买⼊股票了，因为不可能有前⼀天推出来。
所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现⾦就是0，所以dp[0][1] = 0;

4. 确定遍历顺序

从递推公式可以看出dp[i]都是有dp[i - 1]推导出来的，那么⼀定是从前向后遍历。

5. 举例推导dp数组

以示例1，输⼊：[7,1,5,3,6,4]为例，dp数组状态如下：

dp[5][1]就是最终结果。为什么不是dp[5][0]呢？
因为本题中不持有股票状态所得⾦钱⼀定⽐持有股票状态得到的多！
以上分析完毕，java代码如下：

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

从递推公式可以看出，dp[i]只是依赖于dp[i - 1]的状态。

            dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

那么我们只需要记录当前天的dp状态和前⼀天的dp状态就可以了，可以使⽤滚动数组来节省空间，代码如下：

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

观察上面代码我们可以发现每次递归公式中每次计算都要取模运算和数字类容交换，其实我们最后要得到的还是当天的状态，所以可以不用数组直接用两个变量储存当天状态即可。 Java代码如下：

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

动态规划买卖股票的最佳时机问题01：买卖股票的最佳时机