代码随想录算法训练营第49天 | 动态规划 part10 ● 121. 买卖股票的最佳时机 ● 122.买卖股票的最佳时机II

#121 买卖股票的最佳时机 1 

我自己写的，用的“买卖股票的最佳时机 ii "的贪心算法：把利润分成单天单天的利润之和，让累计和<0时候，不如全都抛弃，从下一个开始计算。

int maxProfit(vector<int>& prices) {
        int profit=0;
        int ans=0;
        
        for(int i=1;i<prices.size();i++){
            if(profit+prices[i]-prices[i-1]<=0) profit=0;
            else {
                profit+=prices[i]-prices[i-1];
                ans=max(ans,profit);
            }
        }
        return ans;
    }

这是股票2的贪心（可买卖很多次），对比一下：

int maxProfit(vector<int>& prices) {
        int profit=0;
        for(int i=1;i<prices.size();i++){
            if(profit+prices[i]-prices[i-1]<0) ;//do nothing
            else{
                profit= max(profit,profit+prices[i]-prices[i-1]);
            }
        }
        return profit;
    }

随想录的贪心，好棒：

int maxProfit(vector<int>& prices) {
        int profit=0;
        int low=INT_MAX;
        
        
        for(int i=0;i<prices.size();i++){
            low=min(low,prices[i]);
            profit=max(profit,prices[i]-low);
            
        }
        return profit;
    }

随想录的dp： dp解法还是要学，因为解决更复杂的股票问题需要在这个基础上变化

int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        }
        return dp[len - 1][1];
    }

注意，这个公式里：dp[i][0] = max(dp[i - 1][0], -prices[i]);  dp[i - 1][0]也可能是负数，所以这个公式也是合理的。而且  dp[i - 1][1] - prices[i] 这样写是错的

 关于选结果：而且最后一天肯定得卖掉，是不持有 即[1]状态

一个改进：从递推公式可以看出，dp[i]只是依赖于dp[i - 1]的状态。所以可以用滚动数组来优化

int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意只开了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }

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

之前贪心做过一次。dp再做一次. 有了股票1 的dp基础，很好做了，自己写的：

int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp(prices.size(),(vector<int>(2,0)));
        //0 hold stock, 1 not hold
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.size();i++){
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        return dp[prices.size()-1][1];
    }

自己写的用滚动数组优化：几个易错点 一个是 prices[i] 里面不要%2， 然后return dp[1][1];这个不对，要写return dp[(prices.size()-1)%2][1];

int maxProfit(vector<int>& prices) {
        //vector<vector<int>> dp(prices.size(),(vector<int>(2,0)));
        vector<vector<int>> dp(2,vector<int>(2));
        //0 hold stock, 1 not hold
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.size();i++){
            dp[i%2][0]=max(dp[(i-1)%2][0],dp[(i-1)%2][1]-prices[i]);
            dp[i%2][1]=max(dp[(i-1)%2][1],dp[(i-1)%2][0]+prices[i]);
        }

        //return dp[1][1];
        return dp[(prices.size()-1)%2][1];
    
    }