<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer <code>fee</code> representing a transaction fee.</p>

<p>Find the maximum profit you can achieve. You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction.</p>

<p><strong>Note:</strong></p>

<ul>
	<li>You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</li>
	<li>The transaction fee is only charged once for each stock purchase and sale.</li>
</ul>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> prices = [1,3,2,8,4,9], fee = 2
<strong>Output:</strong> 8
<strong>Explanation:</strong> The maximum profit can be achieved by:
- Buying at prices[0] = 1
- Selling at prices[3] = 8
- Buying at prices[4] = 4
- Selling at prices[5] = 9
The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> prices = [1,3,7,5,10,3], fee = 3
<strong>Output:</strong> 6
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= prices.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>1 &lt;= prices[i] &lt; 5 * 10<sup>4</sup></code></li>
	<li><code>0 &lt;= fee &lt; 5 * 10<sup>4</sup></code></li>
</ul>

class Solution {
public:
   int findMaxProfit(int canBuy,int fee,int indx,vector<int>&prices,vector<vector<int>>&dp){
         int n=prices.size();
         dp[0][n-1] = prices[n-1]-fee;
         dp[1][n-1] = 0;
         int comp=0;
         
            for(int j = n-2 ;j>=0; j--){
                for(int canBuy=0;canBuy<2;canBuy++)
                {
                if(canBuy==1){
                dp[canBuy][j] = max(-prices[j]+dp[0][j+1],dp[1][j+1]);
            //    cout<<j<<" "<<dp[1][j]<<" "<<-prices[j]+dp[0][j+1]<<" "<<dp[1][j+1]<<endl;
                }
                else{
                //    cout<<j<<" "<<dp[1][j+1]<<endl;
                    dp[canBuy][j] = max(prices[j]+dp[1][j+1]-fee,dp[0][j+1]);
                  //  cout<<j<<" "<<dp[0][j]<<" "<<prices[j]+dp[1][j+1]<<" "<<dp[0][j+1]<<endl;

                    //if(dp[canBuy][j]==prices[j]+dp[1][j+1]){
                      //  comp++;
                    }
                }
        }
      //  }

        return dp[1][0];
        // if(indx>=prices.size())
        // return 0;

        // if(dp[canBuy][indx] != -1)
        // return dp[canBuy][indx];

        // if(canBuy==1){ 
        // return dp[canBuy][indx] = max(-prices[indx] + findMaxProfit(0,fee,indx+1,prices,dp),findMaxProfit(1,fee,indx+1,prices,dp));
        // }

        // else{
        //      return dp[canBuy][indx]=max(prices[indx]-fee + findMaxProfit(1,fee,indx+1,prices,dp),
        //     findMaxProfit(0,fee,indx+1,prices,dp) ); 
        //     //return max(prices[indx] + findMaxProfit(1,indx,indx+1,prices,dp),findMaxProfit(0,sellDay,indx+1,prices,dp) ); 
        // }

    }
    int maxProfit(vector<int>& prices, int fee) {
        int indx=0;
        int canBuy=1;
       // vector<vector<int>>dp(2,vector<int>(prices.size(),-1));
        vector<vector<int>>dp(2,vector<int>(prices.size(),INT_MIN) );

        return findMaxProfit(canBuy,fee,indx,prices,dp);
    }
};
64903