leetcode Best Time to Buy and Sell Stock I II III IV

121. Best Time to Buy and Sell Stock
     遍历一次数组，记录最小值，每次计算与最小值之间的差值为利润，最后选取利润最大的。

int  INF=0x7ffffffe;
int maxProfit(vector<int>& prices) {
    int min=INF;
    int profit=0;
    int tmp;
    for (int i=0;i<prices.size();i++){
        if(prices[i]<min){
            min=prices[i];
        }
        tmp=prices[i]-min;
        if(tmp>profit)
            profit=tmp;
    }
    return profit;
}

122. Best Time to Buy and Sell Stock II
     当第二天股票价格下落时，在这一天卖出，获得最小值的办法同第一题

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

    }
    if(prices[prices.size()-1]>min)
        profit+=prices[prices.size()-1]-min;
    return profit;

}

123. Best Time to Buy and Sell Stock III
     使用动态规划:
     某一次卖出时的利润：买入时的利润加上卖出的价格
     sell[k]=max(sell[k],buy[k]+sell_price)
     某一次买入时的利润：上一次卖出时的利润减去这次买入的价格
     buy[k]=max(buy[k],sell[k-1]-buy_price)
     因为这里只有两次事务（k=2），所以可以使用变量代替数组

int maxProfit(vector<int>& prices) {
    if(prices.size()==0)
        return 0;
    int buy1=numeric_limits<int>::min();
    int buy2=numeric_limits<int>::min();
    int sell1=0,sell2=0;
    for (auto p:prices){
        sell2=max(sell2,buy2+p);
        buy2=max(buy2,sell1-p);
        sell1=max(sell1,buy1+p);
        buy1=max(buy1,-p);
    }
    return sell2;
    
}

188. Best Time to Buy and Sell Stock IV
     按照III的思路来写，只不过这里数组元素数为k，代码如下：

int maxProfit(int k, vector<int>& prices) {
    if(prices.size()==0 || k==0)
        return 0;
    vector<int>buy(k,numeric_limits<int>::min());
    vector<int>sell(k,0);

    for(auto p:prices){
        for(int j=k-1;j>=0;j--){
            sell[j]=max(sell[j],buy[j]+p);
            if(j==0)
                buy[j]=max(buy[j],-p);
            else buy[j]=max(buy[j],sell[j-1]-p);
        }
    }
    return sell.back();
}

始终报错：

这里感觉是超内存了，参考了一下discuss里的解法，加入了一个函数，就accepted了。

int maxP(vector<int> & p) {
    int res = 0;
    for (int i = 1; i < p.size(); i++) {
        if (p[i] > p[i-1]) {
            res += p[i] - p[i-1];
        }
    }
    return res;
}
int maxProfit(int k, vector<int>& prices) {   
    if(prices.size()==0 || k==0)
        return 0;
    if (k >= prices.size() / 2) 
        return maxP(prices);
    vector<int>buy(k,numeric_limits<int>::min());
    vector<int>sell(k,0);

    for(auto p:prices){
        for(int j=k-1;j>=0;j--){
            sell[j]=max(sell[j],buy[j]+p);
            if(j==0)
                buy[j]=max(buy[j],-p);
            else buy[j]=max(buy[j],sell[j-1]-p);
        }
    }

    return sell.back();
}