Best Time to Buy and Sell Stock I II III IV

一、Best Time to Buy and Sell Stock I

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.

Example 1:

Input: [7, 1, 5, 3, 6, 4]
Output: 5

max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)

Example 2:

Input: [7, 6, 4, 3, 1]
Output: 0

In this case, no transaction is done, i.e. max profit = 0.

class Solution {
public:
    //遍历一次，每次更新最小值，并且当前值与最小值相减，如果大于最大收入则更新最大收入
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0) return 0;
        int Min=prices[0],res=0;
        for(int i=0;i<len;i++)
        {
            if(prices[i]<Min) Min=prices[i];
            res=res>(prices[i]-Min)?res:(prices[i]-Min);
        }
        return res;
       
    }
};

二、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) {
        int len=prices.size();
        if(len==0||len==1) return 0;
        int Max=0,i=1;
        while(i<len)
        {
            while(i<len&&prices[i-1]>=prices[i])
                i++;
            int valley=prices[i-1];
            while(i<len&&prices[i-1]<prices[i])
                i++;
            int peek=prices[i-1];
            Max+=(peek-valley);
        }
        return Max;
    }
};

法二：

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

三、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).

class Solution {
public:
    //利用四个状态来解答这个题目,假设才开始手里有 0 块钱
    /*
    1、sell2[i]:前i天进行第二笔交易中的卖股票状态后剩余最多的钱
    2、buy2[i]:前i天进行第二笔交易中的买股票状态后剩余最多的钱
    3、sell1[i]:前i天进行第一笔交易中的卖股票状态后剩余最多的钱
    4、buy1[i]：
    sell2[i]=max(sell2[i-1],buy2[i-1]+prices[i]);
    buy2[i]=max(buy2[i-1],sell1[i-1]-prices[i]);
    sell1[i]=max(sell1[i-1],buy1[i-1]+prices[i]);
    buy1[i]=max(buy1[i],-prices[i]);
    */
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0||len==1) return 0;
        int sell2=0;
        int sell1=0;
        int buy2=INT_MIN;
        int buy1=INT_MIN;
        for(int i=0;i<len;i++){
            sell2=max(sell2,buy2+prices[i]);
            buy2=max(buy2,sell1-prices[i]);
            sell1=max(sell1,buy1+prices[i]);
            buy1=max(buy1,-prices[i]);
        }
        return max(sell1,sell2);
    }
};

四：Best Time to Buy and Sell Stock IV

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 k transactions.

class Solution {
public:
    //一次交易代表（买一次并且卖一次）当交易次数k大于数组长度的一半的时候，交易次数就会溢出，就相当于 随便交易求最大利润，就是用贪心解决(II)。
    /*如果交易次数不到一半
        采用动态规划来解决问题。 
    我们需要维护如下两个量： 
    global[i][j]:当前到达第i天最多可以进行j次交易，所得到的最大利润。 
    local[i][j]:当前到达第i天最多可以进行j次交易，而且最后一次交易在当天卖出，所得到的最大利润。 
    状态转移方程： 
    global[i][j] = max(local[i][j], global[i-1][j]) 
    上述方程比较两个量的大小：①当前局部最大值；第i天交易了②过往全局最大值。到第i-1天进行j次交易的最大值，第i天没有交易 
    local[i][j] = max(global[i-1][j-1] + max(diff, 0), local[i-1][j] + diff) 
    上述方程比较两个量的大小： 
    ①全局到i-1天进行j-1次交易，然后加上今天的交易（如果今天的交易赚钱的话）。 
    ②取局部第i-1天进行j次交易，然后加上今天的差值（local[i-1][j]是第i-1天卖出的交易，它加上diff后变成第i天卖出，并不会增加交易次数。无论diff是正还是负都       要加上，否则就不满足local[i][j]必须在最后一天卖出的条件了）
    */
    int maxProfit(int k, vector<int>& prices) {
        int len=prices.size();
        if(len==0||len==1) return 0;
        if(k>=len/2)  return quickSolve(prices);
        int global[k+1]={0};
        int local[k+1]={0};
        int diff=0;
        for(int i=1;i<len;i++)
        {
            diff=prices[i]-prices[i-1];
            for(int j=k;j>=1;j--)
            {
                local[j]=max(global[j-1]+max(diff,0),local[j]+diff);
                global[j]=max(global[j],local[j]);
            }
        }
        return global[k];
    }
private:
    int quickSolve(vector<int>& prices)
    {
        int res=0;
        for(int i=1;i<prices.size();i++)
        {
            if(prices[i]>prices[i-1]) res+=(prices[i]-prices[i-1]);
        }
        return  res;
    }
};