Best Time to Buy and Sell Stock系列

Best Time to Buy and Sell Stock

 

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

 

方法一：暴力破解，分别计算出前后量元素的的差，去最大值，时间复杂度为O(n²)，代码略

方法二：设f(i) = a[i] - min{a1,a2...ai}，即在第i天卖出时能获得的最大利润，那么有

f(0) = 0;

f(i-1) = a[i-1] - min{a1,a2...ai-1}，min{a1,a2...ai} = min{min{a1,a2...ai-1]}, a[i]} = min{a[i-1]-f(i-1),a[i]}

so  f(i) = a[i] - min{a[i-1]-f(i-1), a[i]}

题目要求在这n天内买入卖出一次并获取最大利润，则就是在f数组中求最大值，时间复杂度为O(n)代码如下：

 

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if( prices.size() < 2 ) return 0;   //如果元素个数少于2个，直接返回0
        const int len = prices.size();
        int dp[len];
        dp[0] = 0;
        int ans = 0;
        for(int i=1; i<len; ++i) {
            dp[i] = prices[i] - min(prices[i], prices[i-1]-dp[i-1]);    //f(i) = a[i] - min{a[i-1]-f(i-1), a[i]}
            ans = max(ans, dp[i]);  //去dp数组中的最大元素
        }
        return ans;
    }
};

 

方法三：设f(i)为第0天到第i天内获得的最大利润，minprice[i]为第0天到第i天的最小股票价格，那么有

f(i) = max{ f(i-1),  a[i] - minprice[i-1] }，其中f(0) = 0，minprice[0] = a[0];

so 答案就是f数组中的最大值，时间复杂度为O(n)，代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if( prices.size() < 2 ) return 0;   //如果元素个数少于2个，直接返回0
        const int len = prices.size();
        int dp[len];
        dp[0] = 0;
        int minprice = prices[0];
        int ans = 0;
        for(int i=1; i<len; ++i) {
            dp[i] = max( dp[i-1], prices[i]-minprice ); //f(i) = max{ f(i-1),  a[i] - minprice[i-1] }
            minprice = min( minprice, prices[i] );
            ans = max(ans, dp[i]);  //去dp数组中的最大元素
        }
        return ans;
    }
};

方法四：知prices[0],prices[1],prices[2]...prices[n-1]来构建dv[0],dv[1]...dv[n-2]，其中dv[i] = prices[i+1]-prices[i]，要求在0~n-1天内获得最大利润，实质就是求在dv数列中求最大子数组之和，最大子数组之和求法请见http://www.cnblogs.com/bugfly/p/3922390.html，时间复杂度也为O(n)，代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if( prices.size() < 2 ) return 0;
        vector<int> dv( prices.size()-1, 0 );   //构建差值数组
        for(int i=0; i<prices.size()-1; ++i)
            dv[i] = prices[i+1] - prices[i];
        int sum = 0;
        int ans = 0;
        for(int i=0; i<dv.size(); ++i) {    //求最大连续子数列和
            sum += dv[i];
            ans = max(ans, sum);
            if( sum < 0 ) sum = 0;
        }
        return ans;
    }
};

 

Best Time to Buy and Sell Stock II

 

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

 

方法一：寻找每一个递增区间，每个区间的以最低价买入，最高价卖出。代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        const int len = prices.size();
        if( len < 2 ) return 0;
        int left = 0;
        int ans = 0;
        while( left < len ) {
            int right = left+1;
            while( right < len && prices[right-1] <= prices[right] ) ++right;//寻找每个非严格递增区间，[left,right)就是一个递增区间
            ans += prices[right-1] - prices[left];  //最低价买入，最高价卖出
            left = right;
        }
        return ans;
    }
};

方法二：使用Best Time to Buy and Sell Stock的方法四，将dv中的大于0的元素全部加起来，就是题目要求的答案，代码如下：

 

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if( prices.size() < 2 ) return 0;
        vector<int> dv(prices.size()-1, 0);
        for(int i=0; i<dv.size(); ++i)
            dv[i] = prices[i+1] - prices[i];
        int ans = 0;
        for(int i=0; i<dv.size(); ++i)
            if( dv[i] > 0 ) ans += dv[i];
        return ans;
    }
};

 

 

 

Best Time to Buy and Sell Stock III

 

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

 

设dp1[i]表示在0...i中获得的最大利润，dp2[i]表示在i...n-1中获得的最大利润，那么dp[i]就表示在0...n-1中买卖2次获得的最大利润，即dp[i] = dp1[i] + dp2[i]，则要获取最大利润就是求dp数组的最大值

状态转移方程如下：

dp1[i] = max{ dp1[i-1], a[i] - minprice };

dp2[i] = max{ dp2[i+1], maxprice - a[i] };

时间复杂度为O(n)，代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        const int len = prices.size();
        if( len < 2 ) return 0;
        int dp1[len], dp2[len];
        dp1[0] = 0; //初始化
        int minprice = prices[0];
        for(int i=1; i<len; ++i) {
            dp1[i] = max( dp1[i-1], prices[i] - minprice ); //dp1[i] = max{ dp1[i-1], a[i] - minprice };
            minprice = min( minprice, prices[i] );
        }  
        dp2[len-1] = 0; //初始化
        int maxprice = prices[len-1];
        for(int i=len-2; i>=0; --i) {
            dp2[i] = max( dp2[i+1], maxprice - prices[i] ); //dp2[i] = max{ dp2[i+1], maxprice - a[i] };
            maxprice = max( maxprice, prices[i] );
        }
        int ans = 0;
        for(int i=0; i<len; ++i)
            ans = max( ans, dp1[i]+dp2[i] );    //dp[i] = dp1[i] + dp2[i]
        return ans;
    }
};