代码随想录动态规划——买卖股票的最佳时机

题目

给定一个数组 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

思路

贪心算法：
因为股票只买卖一次，取最左边的最小值，取最右边的最大值，得到的差值就是最大利润

java代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        // 找到一个最小的购入点
        int low = Integer.MAX_VALUE;
        // res不断更新，直到数组循环完毕
        int res = 0;
        for(int i = 0; i < prices.length; i++){
            low = Math.min(prices[i], low);
            res = Math.max(prices[i] - low, res);
        }
        return res;
    }
}

动规五部曲：

1. 确定dp数组和下标含义
   dp[i][0] 表示第 i 天持有股票所得的最大现金
   其中一开始现金是0，加入第 i 天买入的股票后现金就是-price[i]
dp[i][1] 表示第 i 天不持有股票所得的最大现金
2. 确定递推公式
   如果第i天持有（可能买也可能不买/保持原状）股票即dp[i][0]， 那么可以由两个状态推出来
   （1）第i-1天就持有股票，第 i 天继续保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
   （2）第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]（因为只能买卖一次，第i天买就表示是第一次买，前i-1天没有交易记录，买入就是直接减去当天价格即可）
   那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i])
   如果第i天不持有（可能卖出或者保持原状）股票即dp[i][1]， 也可以由两个状态推出来
   （1）第i-1天卖出股票，第 i 天保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
   （2）第i天卖出股票，所得现金就是今天股票卖的价格+前i-1天持有股票的现金和即：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[0][0]和dp[0][1]推导出来，相当于就是最开始的时候买或者不买，买那么现金就是负数，不买现金就是0
   其中dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] = - prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4. 确定遍历顺序
   从前往后遍历即可
5. 举例推导dp数组
   以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：
   
   java代码如下：

class Solution {
	public int maxProfit(int[] prices){
		if(prices == null || prices.length == 0){
			return 0;
		}
		int n = prices.length;
		// dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[n][2];
        int result = 0;
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < n; i++){
        	dp[i][0] = Math.max(dp[i-1][0], -prices[i]);
        	dp[i][1] = Math.max(dp[i-1][0] + prices[i],dp[i-1][1]);
        }
        return dp[n-1][1];
	}
}

//优化空间(滚动数组)
class Solution{
    public int maxProfit(int[] prices){
        if(prices.length == 0){
            return 0;
        }
        int[] dp = new int[2];
        dp[0] = -prices[0];
        dp[1] = 0;
        for(int i = 1; i < prices.length; i++){
            dp[0] = Math.max(dp[0], -prices[i]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i]);
        }
        return dp[1];
    }
}