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 。

示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：
1 <= prices.length <= 3 * 10 ^ 4
0 <= prices[i] <= 10 ^ 4

方法1：动态规划
主要思路：
（1）对于当天可以获得最大利润，可以在两种状态下讨论，一种是当前持有股票，一种是当前不持有股票：
（a）对于当前持有股票，则可能是从两种方式转化而来，一种是一直都持有，一种是当天刚买的；
（b）对于当前不持有股票，则同样是可能从两种方式转化而来，一种是一直没有持有，一种是当前刚卖掉；
（2）根据上述，则使用动态数组vector<vector> dp(size_prices,vector(2,0));则：
（a）dp[ i ][ 0]表示持有股票时可以获得最大利润， 若是一直持有，则 dp[i][0]=dp[i-1][0];，若是刚买入，则只能是从持有的状态减去当天的股价，既 dp[i][0]=dp[i-1][1]-prices[i]；，故总的来说dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
（b）dp[ i ][ 1 ]表示不持有股票状态下可以获得最大利润，则若是一直不持有，则dp[i][1]=dp[i-1][1];，若是当天刚卖出，则是从持有的状态加上当前的股价表示利润，则dp[i][1]=dp[i-1][0]+prices[i];，故总的来说dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
（3）最后返回卖出是的利润即可，既dp[size_prices-1][1]；

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<2)
            return 0;
        
        int size_prices=prices.size();
        vector<vector<int>> dp(size_prices,vector<int>(2,0));

        dp[0][0]=-prices[0];//初始化，因为持有状态要持有股票
        
        for(int i=1;i<size_prices;++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[size_prices-1][1];//返货最大利润
    }
};

方法2：动态规划，压入使用内存
主要思路：
（1）思路和方法1类似，不过观察方法1的代码，可以看到当天的利润之和前一天的有关，故可以只保存前一天的利润，没必要使用整个数组进行保存；

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<2)
            return 0;
        
        int size_prices=prices.size();
        //保存前一天的利润
        int profit0=-prices[0];
        int profit1=0;

        for(int i=1;i<size_prices;++i){
        	//获得当前的利润
            int new_profit0=max(profit0,profit1-prices[i]);
            int new_profit1=max(profit1,profit0+prices[i]);
			//更新前一天的利润
            profit0=new_profit0;
            profit1=new_profit1;
        }

        return profit1;
    }
};

方法3：
主要思路：
（1）获得每一个的增长机会，既只要prices[i]-prices[i-1]，既表示可以获得该利润

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<2)
            return 0;
        
        int size_prices=prices.size();
        
        int profit=0;

        for(int i=1;i<size_prices;++i){
            if(prices[i]>prices[i-1]){
                profit+=prices[i]-prices[i-1];
            }
        }

        return profit;
    }
};