Title Description

Given an integer array prices, where the i-th element represents the stock price on the i-th day; The integer fee represents the handling fee for trading stocks.

You can complete transactions indefinitely, but you need to pay a handling fee for each transaction. If you have bought a stock, you can't continue to buy it until you sell it.

Returns the maximum profit.

Note: a transaction here refers to the whole process of buying, holding and selling stocks. You only need to pay a handling fee for each transaction.

Example 1:

Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
 Output: 8
 Explanation: maximum profit:  
Buy here prices[0] = 1
 Sell here prices[3] = 8
 Buy here prices[4] = 4
 Sell here prices[5] = 9
 Total profit: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
 Example 2:

Input: prices = [1,3,7,5,10,3], fee = 3
 Output: 6

Tips:

1 <= prices.length <= 5 * 104 1 <= prices[i] < 5 * 104 0 <= fee < 5 * 104

Source: LeetCode link: LeetCode CN COM / problems / be... [1] the copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

Problem solving ideas

Idea 1: dynamic programming implementation

Dynamic programming Trilogy

• Define dp meaning
  • Definition dp[n][2]:
  • N means there are two states on day n, holding or not holding
  • dp[i][0] the maximum profit obtained by not holding on day I;
  • dp[i][1] the maximum profit obtained by holding on day I; (tip: hold, not buy)
• Define the state transition equation: For today's non holding, it can be transferred from two states: 1 Not yesterday; 2. Hold it yesterday, sell it today and pay the handling fee fee fee fee. Whichever is greater. For today's holding, it can be transferred from two states: 1 Also held yesterday; 2. Do not hold yesterday, buy today. Whichever is greater.
  • dp[i][1]=Math.max(dp[i-1][0]-prices[i],dp[i-1][1]);
  • dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]+prices[i]-fee);
• Initialize dp;
  • Not held: dp[0][0]=0;
  • Holding: dp[0][1]=-prices[0] (i.e. buying with price[0])

Since DP [n] [0] > DP [i] [1], the profit of not holding shares on the same day must be greater than that of holding shares on the same day, so return dp[len-1][0]

Spatiotemporal complexity

• Time complexity: O(n), you can traverse it once.
• Space complexity: O(n)

code

function maxProfit(prices: number[], fee: number): number {
    
    let len=prices.length;
     // define dp
     let dp=new Array(len);
     for(let i=0;i<len;i++){
         dp[i]=new Array(2).fill(0);
     }
     // init dp 
     dp[0][0]=0;
     dp[0][1]=-prices[0];
     for(let i=1;i<len;i++){
         dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]+prices[i]-fee);
         dp[i][1]=Math.max(dp[i-1][0]-prices[i],dp[i-1][1]);
     }
     console.log(dp);
    return dp[len-1][0]
};

optimization

Dimensionality reduction: during state transition, dp[i] will only be transferred from dp[i-1], so the first dimension can be removed:

Spatiotemporal complexity

• Time complexity: O(n), you can traverse it once.
• Space complexity: O(1)

 function maxProfit(prices: number[], fee: number): number {
    
    let len:number=prices.length;
     // define dp
     let dp=new Array(2);

     // init dp 
     dp[0]=0;
     dp[1]=-prices[0];
     for(let i=1;i<len;i++){
         let temp=dp[0]
         dp[0]=Math.max(dp[0],dp[1]+prices[i]-fee);
         dp[1]=Math.max(temp-prices[i],dp[1]);
     }
     console.log(dp);
    return dp[0]
};

Idea 2: greedy algorithm

• Calculating the handling fee when buying can get a greedy method;
• We define buy as: on the premise of maximizing benefits, when we have a stock in hand, then his buying price is the lowest.
  • profit=prices[i]-buy;
  • But at this time, our selling may not be the optimal solution. For example, the price continues to rise the next day;
  • Therefore, we can assume that there is a repudiation operation, assuming that there is a stock with a purchase price of prices[i],
  • Update buy to prices[i]:buy=prices[i];
  • If the price continues to rise the next day, we will get prices[i+1]-prices[i]. At this time, plus the income of prices[i]-buy of the previous day,
  • It can be seen from the above that it is equivalent to selling the next day without any operation: prices[i+1]-buy
  • Initialize to buy=prices[0]+fee;
  • If the current stock price [i] + fee < buy; Then we update the lowest purchase price buy;
  • If the current stock is larger than buy, we can sell it directly to make a profit
  • In other cases, it is not worth selling;

Spatiotemporal complexity

• Time complexity: O(n), you can traverse it once.
• Space complexity: O(1)

function maxProfit(prices: number[], fee: number): number {
  let len=prices.length;
  let buy=prices[0]+fee;
  let profit=0;
  for(let i=1;i<len;i++){
      if(prices[i]+fee<buy){
          buy=prices[i]+fee;
      }else if(prices[i]>buy){
          profit+=prices[i]-buy
          buy=prices[i]
      }
  }// end of for 
  return profit
};

reference material

[1]https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee: https://link.juejin.cn/?target=https%3A%2F%2Fleetcode-cn.com%2Fproblems%2Fbest-time-to-buy-and-sell-stock-with-transaction-fee