121. 买卖股票的最佳时机***【力扣】

题意理解

给定一组数字，问如何只取其中两个数字，使得后一个数减去前一个数的差值最大？

问题分析

方法1：动态规划，寻找递推式

状态量是前i个数字的最大收益；状态方程是

DP[0] = 0;  i = 0;

DP[i] = max{DP[i-1], prices[i] - min { prices[0]...[i-1] } },   1 <= i < n

方法2：数组

设置最小价格，和最大利润：最大利润等于当前价格减最小价格得到。（遍历避开了最大价格在最小价格之前的情况）。

其他

0802：放弃动规，状态变化太复杂了，没必要；方法2的思想是动规，当前的最大利润和之前的最小值和之前的最大利润有关。https://leetcode.com/articles/best-time-to-buy-and-sell-stock/

链接

    int maxProfit(vector<int>& prices) {
        int min_price = INT_MAX, max_profit = 0;
        for (auto it = prices.begin(); it != prices.end(); it++) { //每次计算前i次的最大收益
            if (*it < min_price) min_price = *it;    //如果第i次（当前）是最小值，更新最小值
            max_profit = max(max_profit, *it - min_price); //当前值和最小值的差（更新的收益），即当前可能的最大收益，与历史最大收益两者之间的大者为新的最大收益
        }
        return max_profit;
    

最大利润+最小价格方法

    int maxProfit(vector<int>& prices) {
        int min_price = INT_MAX;    //最小价格
        int max_profit = 0;    //最大利润
        for (int i = 0; i != prices.size(); i ++)    //遍历数组
        {
            if (prices[i] < min_price)    //更新最小价格
            {
                min_price = prices[i];
            }
            else if (max_profit < prices[i] - min_price)    //更新最大利润（当前价格-最小价格）
            {
                max_profit = prices[i] - min_price;
            }
        }
        return max_profit;
    }

    int maxProfit(vector<int>& prices) {
       int ans = 0;
       int len = prices.size();
        if (!len) {
            return 0;
        }
       vector<vector<int>> dp(len, vector<int>(2,0));
       dp[0][0] = 0;    //不持有
        dp[0][1] = -prices[0];  //持有
        for (int i = 1; i != len; i ++) {
            dp[i][0] = max (dp[i - 1][0], dp[i - 1][1] + prices[i]);//卖可以很多次
            dp[i][1] = max (dp[i - 1][1], - prices[i]);//只允许一次交易，上一次一定不可能，设置为0.
        }
        return dp[len -1][0];
    }

    int maxProfit(vector<int>& prices) {
       int ans = 0;
       int len = prices.size();
        if (!len) {
            return 0;
        }
        /*
       vector<vector<int>> dp(len, vector<int>(2,0));
       dp[0][0] = 0;    //不持有
        dp[0][1] = -prices[0];  //持有
        */
        int dp_0 = 0;
        int dp_1 = - prices[0];
        for (int i = 1; i != len; i ++) {
            /*
            dp[i][0] = max (dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max (dp[i - 1][1], - prices[i]);
            */
            dp_0 = max (dp_0, dp_1 + prices[i]);
            dp_1 = max (dp_1, -prices[i]);
        }
        //return dp[len -1][0];
        return dp_0;
    }

取dp数组，降低空间复杂度