Stock Buy and Sell – Max 2 Transactions Allowed

Last Updated : 21 Jan, 2026

Given an array prices[], where prices[i] represents the price of a stock on the i-th day, find the maximum profit that can be earned by performing at most two transactions.

Each transaction consists of one buy and one sell operation, and a new transaction can begin only after the previous one is completed (i.e., you cannot hold more than one stock at a time).

Examples: 

Input: prices[] = [10, 22, 5, 75, 65, 80]
Output: 87
Explanation:
Buy at 10, sell at 22, profit = 22 - 10 = 12
Buy at 5 and sell at 80, total profit = 12 + (80 - 5) = 87

Input:  prices[] = [100, 30, 15, 10, 8, 25, 80]
Output: 72
Explanation: Only one transaction needed here. Buy at price 8 and sell at 80.

Input:  prices[] = [90, 80, 70, 60, 50]
Output: 0
Explanation: Not possible to earn.

Try it on GfG Practice
redirect icon

Table of Content

[Naive Approach] Using Brute Force - O(n2) Time and O(1) Space

We can use the concept of maximum profit from one transaction to solve this for two transactions. For each day i, we assume the first transaction ends on or before i, and the second transaction starts after i.

  • The profit from the first transaction can be computed by tracking the minimum price so far and finding the maximum difference.
  • The profit from the second transaction can then be calculated by applying the same logic on the remaining days (from i + 1 onward).

By combining these two profits for every possible split point i, we get the maximum achievable profit from at most two transactions.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
using namespace std;
//Driver Code Ends


// Function to find maximum profit 
// with one transaction starting from index idx
int maxProfOne(vector<int> &prices, int idx) {  
    int minSoFar = prices[idx], res = 0;  
    
    for (int i = idx + 1; i < prices.size(); i++) {
        minSoFar = min(minSoFar, prices[i]);      
        res = max(res, prices[i] - minSoFar);
    }  
    return res;
}

// Function to find maximum profit 
// with at most two transactions
int maxProfit(vector<int>& prices) {
    int n = prices.size();
    int minSoFar = prices[0], res = 0;  
     
    for (int i = 1; i < n; i++) {
        if (prices[i] > minSoFar) {
            
            // Profit from first transaction + best profit 
            // from remaining days
            int curr = prices[i] - minSoFar + maxProfOne(prices, i+1);
            res = max(res, curr);
        } 
        else {   
            minSoFar = min(minSoFar, prices[i]);
        }
    }
    return res;
}


//Driver Code Starts
int main() {
    vector<int> prices = { 10, 22, 5, 75, 65, 80 };
    cout << maxProfit(prices);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
class GFG {
//Driver Code Ends


    // Function to find maximum profit 
    // with one transaction starting from index idx
    static int maxProfOne(int[] prices, int idx) {
        int minSoFar = prices[idx], res = 0;

        for (int i = idx + 1; i < prices.length; i++) {
            minSoFar = Math.min(minSoFar, prices[i]);
            res = Math.max(res, prices[i] - minSoFar);
        }
        return res;
    }

    // Function to find maximum profit 
    // with at most two transactions
    static int maxProfit(int[] prices) {
        int n = prices.length;
        int minSoFar = prices[0], res = 0;

        for (int i = 1; i < n; i++) {
            if (prices[i] > minSoFar) {
                
                // Profit from first transaction + best profit
                // from remaining days
                int curr = prices[i] - minSoFar + maxProfOne(prices, i+1);
                res = Math.max(res, curr);
            } else {
                minSoFar = Math.min(minSoFar, prices[i]);
            }
        }
        return res;
    }


//Driver Code Starts
    public static void main(String[] args) {
        int[] prices = {10, 22, 5, 75, 65, 80};
        System.out.println(maxProfit(prices));
    }
}

//Driver Code Ends
Python 
# Function to find maximum profit 
# with one transaction starting from index idx
def maxProfOne(prices, idx):
    minSoFar = prices[idx]
    res = 0

    for i in range(idx + 1, len(prices)):
        minSoFar = min(minSoFar, prices[i])
        res = max(res, prices[i] - minSoFar)
    return res


# Function to find maximum profit 
# with at most two transactions
def maxProfit(prices):
    n = len(prices)
    minSoFar = prices[0]
    res = 0

    for i in range(1, n):
        if prices[i] > minSoFar:

            # Profit from first transaction + best profit 
            # from remaining days
            curr = prices[i] - minSoFar + maxProfOne(prices, i+1)
            res = max(res, curr)
        else:
            minSoFar = min(minSoFar, prices[i])
    return res



#Driver Code Starts
if __name__ == "__main__":
    prices = [10, 22, 5, 75, 65, 80]
    print(maxProfit(prices))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {
//Driver Code Ends


    // Function to find maximum profit 
    // with one transaction starting from index idx
    static int maxProfOne(int[] prices, int idx) {
        int minSoFar = prices[idx], res = 0;

        for (int i = idx + 1; i < prices.Length; i++) {
            minSoFar = Math.Min(minSoFar, prices[i]);
            res = Math.Max(res, prices[i] - minSoFar);
        }
        return res;
    }

    // Function to find maximum profit 
    // with at most two transactions
    static int maxProfit(int[] prices) {
        int n = prices.Length;
        int minSoFar = prices[0], res = 0;

        for (int i = 1; i < n; i++) {
            if (prices[i] > minSoFar) {

                // Profit from first transaction + best profit 
                // from remaining days
                int curr = prices[i] - minSoFar + maxProfOne(prices, i+1);
                res = Math.Max(res, curr);
            } 
            else {
                minSoFar = Math.Min(minSoFar, prices[i]);
            }
        }
        return res;
    }


//Driver Code Starts
    static void Main() {
        int[] prices = {10, 22, 5, 75, 65, 80};
        Console.WriteLine(maxProfit(prices));
    }
}

//Driver Code Ends
JavaScript 
// Function to find maximum profit 
// with one transaction starting from index idx
function maxProfOne(prices, idx) {
    let minSoFar = prices[idx], res = 0;

    for (let i = idx + 1; i < prices.length; i++) {
        minSoFar = Math.min(minSoFar, prices[i]);
        res = Math.max(res, prices[i] - minSoFar);
    }
    return res;
}

// Function to find maximum profit 
// with at most two transactions
function maxProfit(prices) {
    const n = prices.length;
    let minSoFar = prices[0], res = 0;

    for (let i = 1; i < n; i++) {
        if (prices[i] > minSoFar) {

            // Profit from first transaction + best profit 
            // from remaining days
            let curr = prices[i] - minSoFar + maxProfOne(prices, i+1);
            res = Math.max(res, curr);
        } 
        else {
            minSoFar = Math.min(minSoFar, prices[i]);
        }
    }
    return res;
}


// Driver Code
//Driver Code Starts
const prices = [10, 22, 5, 75, 65, 80];
console.log(maxProfit(prices));

//Driver Code Ends

Output
87

[Better Approach 1] Using Postfix Profit Array - O(n) Time and O(n) Space

We can optimize above approach by using a postfix array to store future profits.

First, we calculate profit2[i], which represents the maximum profit achievable from one transaction starting at day i. This is done by traversing from right to left, keeping track of the maximum price so far and updating -

profit2[i] = max(profit2[i + 1], maxPrice - prices[i])

Then, we traverse from left to right to calculate the maximum total profit by combining:

  • The best profit from the first transaction up to day i, and
  • The precomputed profit2[i] (profit from the second transaction after i).

This avoids recalculating profits repeatedly using the idea of prefix (first transaction) and postfix (second transaction) profits.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//Driver Code Ends


int maxProfit(vector<int>& prices) {
    int n = prices.size();
    if (n == 0) return 0;
    
    vector<int> postfix(n, 0);
    int maxPrice = prices[n - 1];

    // Postfix array: max profit with 
    // one transaction from day i to end
    for (int i = n - 2; i >= 0; i--) {
        maxPrice = max(maxPrice, prices[i]);
        postfix[i] = max(postfix[i + 1], maxPrice - prices[i]);
    }

    int minPrice = prices[0], res = postfix[0];

    // Combine prefix (first transaction)
    // and postfix (second transaction)
    for (int i = 1; i < n; i++) {
        minPrice = min(minPrice, prices[i]);
        int first = prices[i] - minPrice;
        res = max(res, first + postfix[i]);
    }

    return res;
}


//Driver Code Starts
int main() {
    vector<int> prices = {10, 22, 5, 75, 65, 80};
    cout << maxProfit(prices);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
class GFG {
//Driver Code Ends

    
    static int maxProfit(int[] prices) {
        int n = prices.length;
        if (n == 0) return 0;
        
        int[] postfix = new int[n];
        int maxPrice = prices[n - 1];

        // Postfix array: max profit with 
        // one transaction from day i to end
        for (int i = n - 2; i >= 0; i--) {
            maxPrice = Math.max(maxPrice, prices[i]);
            postfix[i] = Math.max(postfix[i + 1], maxPrice - prices[i]);
        }

        int minPrice = prices[0], res = postfix[0];

        // Combine prefix (first transaction)
        // and postfix (second transaction)
        for (int i = 1; i < n; i++) {
            minPrice = Math.min(minPrice, prices[i]);
            int first = prices[i] - minPrice;
            res = Math.max(res, first + postfix[i]);
        }

        return res;
    }


//Driver Code Starts
    public static void main(String[] args) {
        int[] prices = {10, 22, 5, 75, 65, 80};
        System.out.println(maxProfit(prices));
    }
}

//Driver Code Ends
Python 
def maxProfit(prices):
    n = len(prices)
    if n == 0:
        return 0

    postfix = [0] * n
    max_price = prices[-1]

    # Postfix array: max profit with 
    # one transaction from day i to end
    for i in range(n - 2, -1, -1):
        max_price = max(max_price, prices[i])
        postfix[i] = max(postfix[i + 1], max_price - prices[i])

    min_price = prices[0]
    res = postfix[0]

    # Combine prefix (first transaction)
    # and postfix (second transaction)
    for i in range(1, n):
        min_price = min(min_price, prices[i])
        first = prices[i] - min_price
        res = max(res, first + postfix[i])

    return res



#Driver Code Starts
if __name__ == '__main__':
    prices = [10, 22, 5, 75, 65, 80]
    print(maxProfit(prices))

#Driver Code Ends
C# 
//Driver Code Starts
using System;
using System.Collections.Generic;

class GFG {
//Driver Code Ends

    
    static int maxProfit(int[] prices) {
        int n = prices.Length;
        if (n == 0) return 0;

        int[] postfix = new int[n];
        int maxPrice = prices[n - 1];

        // Postfix array: max profit with 
        // one transaction from day i to end
        for (int i = n - 2; i >= 0; i--) {
            maxPrice = Math.Max(maxPrice, prices[i]);
            postfix[i] = Math.Max(postfix[i + 1], maxPrice - prices[i]);
        }

        int minPrice = prices[0], res = postfix[0];

        // Combine prefix (first transaction)
        // and postfix (second transaction)
        for (int i = 1; i < n; i++) {
            minPrice = Math.Min(minPrice, prices[i]);
            int first = prices[i] - minPrice;
            res = Math.Max(res, first + postfix[i]);
        }

        return res;
    }


//Driver Code Starts
    static void Main() {
        int[] prices = {10, 22, 5, 75, 65, 80};
        Console.WriteLine(maxProfit(prices));
    }
}

//Driver Code Ends
JavaScript 
function maxProfit(prices) {
    const n = prices.length;
    if (n === 0) return 0;

    const postfix = new Array(n).fill(0);
    let maxPrice = prices[n - 1];

    // Postfix array: max profit with 
    // one transaction from day i to end
    for (let i = n - 2; i >= 0; i--) {
        maxPrice = Math.max(maxPrice, prices[i]);
        postfix[i] = Math.max(postfix[i + 1], maxPrice - prices[i]);
    }

    let minPrice = prices[0];
    let res = postfix[0];

    // Combine prefix (first transaction)
    // and postfix (second transaction)
    for (let i = 1; i < n; i++) {
        minPrice = Math.min(minPrice, prices[i]);
        const first = prices[i] - minPrice;
        res = Math.max(res, first + postfix[i]);
    }

    return res;
}


// Driver Code
//Driver Code Starts
const prices = [10, 22, 5, 75, 65, 80];
console.log(maxProfit(prices));

//Driver Code Ends

Output
87

Idea: Exploring all possibilities

At any given day, we can be in one of two states - ready to buy or ready to sell. So,

The idea is to explore all possible buy and sell decisions while ensuring that at most two transactions are allowed.

Suppose, maxProfitRec(i, k, buy) returns the maximum profit from day i onward, with k transactions left and the option to either buy (buy = 1) or sell (buy = 0).

From each state, we have two choices:

  • Skip the current day and move to the next one.
  • Perform the possible action (buy or sell).

If we are allowed to buy (buy = 1):
profit = max(-prices[i] + maxProfitRec(i+1, k, 0), maxProfitRec(i+1, k, 1))

If we must sell (buy = 0):
profit = max(prices[i] + maxProfitRec(i+1, k-1, 1), maxProfitRec(i+1, k, 0))

The recursion stops when all days are processed or no transactions are left.

[Better Approach 2] Using Top Down Dp - O(n) Time and O(n) Space

To avoid repeated calculations while exploring all possibilities, we can use memoization, where the result of each state (i, k, buy) is stored and reused whenever the same state is encountered again, thus eliminating overlapping subproblems and improving efficiency.

Create a 3D DP table where dp[i][k][buy] stores the maximum profit achievable starting from day i, with k transactions remaining, and the current state being either ready to buy (buy = 1) or ready to sell (buy = 0).

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//Driver Code Ends


// Recursive helper function with memoization
int maxProfitRec(int i, int k, int buy, vector<int> &prices,
                                vector<vector<vector<int>>> &dp) {

    // Base conditions
    if (i == prices.size() || k == 0)
        return 0;

    // If already computed
    if (dp[i][k][buy] != -1)
        return dp[i][k][buy];

    int profit = 0;

    // If we can buy
    if (buy == 1) {
        profit = max(-prices[i] + maxProfitRec(i + 1, k, 0, prices, dp),
                     maxProfitRec(i + 1, k, 1, prices, dp));
    }

    // If we can sell
    else {
        profit = max(prices[i] + maxProfitRec(i + 1, k - 1, 1, prices, dp),
                     maxProfitRec(i + 1, k, 0, prices, dp));
    }

    return dp[i][k][buy] = profit;
}

// Find maximum profit with at most 2 transactions
int maxProfit(vector<int> &prices) {
    int n = prices.size();

    // 3D memo table for states (index, transactions, buy/sell)
    vector<vector<vector<int>>> dp(n, vector<vector<int>>(3, vector<int>(2, -1)));

    return maxProfitRec(0, 2, 1, prices, dp);
}


//Driver Code Starts
int main() {
    vector<int> prices = {10, 22, 5, 75, 65, 80};

    cout << maxProfit(prices);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
import java.util.Arrays;

class GFG {
//Driver Code Ends


    // Recursive helper function with memoization
    static int maxProfitRec(int i, int k, int buy, int[] prices, int[][][] dp) {

        // Base case
        if (i == prices.length || k == 0)
            return 0;

        // If already computed
        if (dp[i][k][buy] != -1)
            return dp[i][k][buy];

        int profit;

        // If we can buy
        if (buy == 1)
            profit = Math.max(-prices[i] + maxProfitRec(i + 1, k, 0, prices, dp),
                              maxProfitRec(i + 1, k, 1, prices, dp));

        // If we can sell
        else
            profit = Math.max(prices[i] + maxProfitRec(i + 1, k - 1, 1, prices, dp),
                              maxProfitRec(i + 1, k, 0, prices, dp));

        return dp[i][k][buy] = profit;
    }

    // Find maximum profit with at most 2 transactions
    static int maxProfit(int[] prices) {
        int n = prices.length;
        
        // 3D memo table for states (index, transactions, buy/sell)
        int[][][] dp = new int[n][3][2];
        for (int[][] arr : dp)
            for (int[] row : arr)
                Arrays.fill(row, -1);

        return maxProfitRec(0, 2, 1, prices, dp);
    }


//Driver Code Starts
    public static void main(String[] args) {
        int[] prices = {10, 22, 5, 75, 65, 80};
        System.out.println(maxProfit(prices));
    }
}

//Driver Code Ends
Python 
# Recursive helper function with memoization
def maxProfitRec(i, k, buy, prices, dp):

    # Base case
    if i == len(prices) or k == 0:
        return 0

    # If already computed
    if dp[i][k][buy] != -1:
        return dp[i][k][buy]

    # If we can buy
    if buy == 1:
        profit = max(-prices[i] + maxProfitRec(i + 1, k, 0, prices, dp),
                     maxProfitRec(i + 1, k, 1, prices, dp))
    else:
        profit = max(prices[i] + maxProfitRec(i + 1, k - 1, 1, prices, dp),
                     maxProfitRec(i + 1, k, 0, prices, dp))

    dp[i][k][buy] = profit
    return profit


# Find maximum profit with at most 2 transactions
def maxProfit(prices):
    n = len(prices)
    
    # 3D memo table for states (index, transactions, buy/sell)
    dp = [[[-1] * 2 for _ in range(3)] for _ in range(n)]
    return maxProfitRec(0, 2, 1, prices, dp)



if __name__ == "__main__":
#Driver Code Starts
    prices = [10, 22, 5, 75, 65, 80]
    print(maxProfit(prices))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {
//Driver Code Ends


    // Recursive helper function with memoization
    static int maxProfitRec(int i, int k, int buy, int[] prices, int[,,] dp) {

        // Base case
        if (i == prices.Length || k == 0)
            return 0;

        // If already computed
        if (dp[i, k, buy] != -1)
            return dp[i, k, buy];

        int profit;

        // If we can buy
        if (buy == 1)
            profit = Math.Max(-prices[i] + maxProfitRec(i + 1, k, 0, prices, dp),
                              maxProfitRec(i + 1, k, 1, prices, dp));

        // If we can sell
        else
            profit = Math.Max(prices[i] + maxProfitRec(i + 1, k - 1, 1, prices, dp),
                              maxProfitRec(i + 1, k, 0, prices, dp));

        return dp[i, k, buy] = profit;
    }

    // Find maximum profit with at most 2 transactions
    static int maxProfit(int[] prices) {
        int n = prices.Length;
        
        // 3D memo table for states (index, transactions, buy/sell)
        int[,,] dp = new int[n, 3, 2];

        for (int i = 0; i < n; i++)
            for (int j = 0; j < 3; j++)
                for (int b = 0; b < 2; b++)
                    dp[i, j, b] = -1;

        return maxProfitRec(0, 2, 1, prices, dp);
    }


//Driver Code Starts
    static void Main() {
        int[] prices = {10, 22, 5, 75, 65, 80};
        Console.WriteLine(maxProfit(prices));
    }
}

//Driver Code Ends
JavaScript 
// Recursive helper function with memoization
function maxProfitRec(i, k, buy, prices, dp) {

    // Base case
    if (i === prices.length || k === 0)
        return 0;

    // If already computed
    if (dp[i][k][buy] !== -1)
        return dp[i][k][buy];

    let profit;

    // If we can buy
    if (buy === 1)
        profit = Math.max(-prices[i] + maxProfitRec(i + 1, k, 0, prices, dp),
                          maxProfitRec(i + 1, k, 1, prices, dp));

    // If we can sell
    else
        profit = Math.max(prices[i] + maxProfitRec(i + 1, k - 1, 1, prices, dp),
                          maxProfitRec(i + 1, k, 0, prices, dp));

    dp[i][k][buy] = profit;
    return profit;
}

// Find maximum profit with at most 2 transactions
function maxProfit(prices) {
    const n = prices.length;
    
    // 3D memo table for states (index, transactions, buy/sell)
    const dp = Array.from({ length: n }, () =>
        Array.from({ length: 3 }, () => Array(2).fill(-1))
    );

    return maxProfitRec(0, 2, 1, prices, dp);
}


// Driver Code
//Driver Code Starts
const prices = [10, 22, 5, 75, 65, 80];
console.log(maxProfit(prices));

//Driver Code Ends

Output
87

[Expected Approach 1] Bottom Up Dp with Space Optimization - O(n) Time and O(1) Space

From the memoized state transitions, we can observe that,

  • dp[i][k][1] = max( -price[i] + dp[i-1][k][0], dp[i-1][k][1] )
  • dp[i][k][0] = max( price[i] + dp[i-1][k-1][1], dp[i-1][k][0] )

Since the current day’s result depends only on the next day’s states, we do not need to store the full 3D DP table.

We maintain two 2D arrays — curr and next, where dp[k][b] represents:

  • k → number of transactions remaining (1 or 2)
  • b → buy/sell state (1 = can buy, 0 = must sell)

We iterate backward from the last day to the first and fill these states:

  • If we can buy (b = 1) → choose the better of:
    Buying today: -prices[i] + next[k][0]
    Skipping today: next[k][1]
  • If we must sell (b = 0) → choose the better of:
    Selling today: prices[i] + next[k - 1][1]
    Skipping today: next[k][0]

After computing for day i, we copy curr to next to move one step backward. Finally, curr[2][1] gives the maximum profit starting from day 0 with 2 transactions allowed.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
//Driver Code Ends


int maxProfit(vector<int> &prices){
    int n = prices.size();
    if (n == 0)
        return 0;

    vector<vector<int>> curr(3, vector<int>(2, 0));
    vector<vector<int>> next(3,  vector<int>(2, 0));

    // Iterate from the last day to the first
    for (int i = n - 1; i >= 0; i--){
        for (int k = 1; k <= 2; k++){
          
            // Calculate for buy state
            curr[k][1] = max(-prices[i] +
                       next[k][0], next[k][1]);
          
            // Calculate for sell state
            curr[k][0] = max(prices[i] +
                    next[k - 1][1], next[k][0]);
        }
        
        // Move current state to next, for the
        // next iteration
        next = curr;
    }

    return curr[2][1];
}


//Driver Code Starts
int main() {
    vector<int> price = { 10, 22, 5, 75, 65, 80 };
    cout << maxProfit(price);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
class GFG {
//Driver Code Ends

    
    static int maxProfit(int[] prices) {
        int n = prices.length;
        if (n == 0)
            return 0;

        int[][] curr = new int[3][2];
        int[][] next = new int[3][2];

        // Iterate from the last day to the first
        for (int i = n - 1; i >= 0; i--) {
            for (int k = 1; k <= 2; k++) {
                
                // Calculate for buy state
                curr[k][1] = Math.max(-prices[i] + next[k][0], next[k][1]);

                // Calculate for sell state
                curr[k][0] = Math.max(prices[i] + next[k - 1][1], next[k][0]);
            }
            
            // Move current state to next, for the
            // next iteration
            next = curr.clone();
        }

        return curr[2][1];
    }


//Driver Code Starts
    public static void main(String[] args) {
        int[] prices = {10, 22, 5, 75, 65, 80};
        System.out.println(maxProfit(prices));
    }
}

//Driver Code Ends
Python 
def maxProfit(prices):
    n = len(prices)
    if n == 0:
        return 0

    curr = [[0] * 2 for _ in range(3)]
    next = [[0] * 2 for _ in range(3)]

    # Iterate from the last day to the first
    for i in range(n - 1, -1, -1):
        for k in range(1, 3):
            
            # Calculate for buy state
            curr[k][1] = max(-prices[i] + next[k][0], next[k][1])
            
            # Calculate for sell state
            curr[k][0] = max(prices[i] + next[k - 1][1], next[k][0])
        
        # Move current state to next, for the
        # next iteration
        next = [row[:] for row in curr]

    return curr[2][1]


if __name__ == "__main__":
#Driver Code Starts
    prices = [10, 22, 5, 75, 65, 80]
    print(maxProfit(prices))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {
//Driver Code Ends

    
    static int maxProfit(int[] prices) {
        int n = prices.Length;
        if (n == 0)
            return 0;

        int[,] curr = new int[3, 2];
        int[,] next = new int[3, 2];

        // Iterate from the last day to the first
        for (int i = n - 1; i >= 0; i--) {
            for (int k = 1; k <= 2; k++) {
                
                // Calculate for buy state
                curr[k, 1] = Math.Max(-prices[i] + next[k, 0], next[k, 1]);

                // Calculate for sell state
                curr[k, 0] = Math.Max(prices[i] + next[k - 1, 1], next[k, 0]);
            }
            
            // Move current state to next, for the
            // next iteration
            Array.Copy(curr, next, curr.Length);
        }

        return curr[2, 1];
    }


//Driver Code Starts
    static void Main(string[] args) {
        int[] prices = {10, 22, 5, 75, 65, 80};
        Console.WriteLine(maxProfit(prices));
    }
}

//Driver Code Ends
JavaScript 
function maxProfit(prices) {
    let n = prices.length;
    if (n === 0)
        return 0;

    let curr = Array.from({ length: 3 }, () => [0, 0]);
    let next = Array.from({ length: 3 }, () => [0, 0]);

    // Iterate from the last day to the first
    for (let i = n - 1; i >= 0; i--) {
        for (let k = 1; k <= 2; k++) {
            
            // Calculate for buy state
            curr[k][1] = Math.max(-prices[i] + next[k][0], next[k][1]);

            // Calculate for sell state
            curr[k][0] = Math.max(prices[i] + next[k - 1][1], next[k][0]);
        }
        
        // Move current state to next, for the
        // next iteration
        next = curr.map(row => [...row]);
    }

    return curr[2][1];
}


// Driver Code
//Driver Code Starts
let prices = [10, 22, 5, 75, 65, 80];
console.log(maxProfit(prices));
//Driver Code Ends

Output
87

[Expected Approach 2] Further Space Optimization - O(n) Time and O(1) Space

This approach optimizes the previous DP solution by observing that at any given point, the maximum profit depends only on a few previous states, not the entire DP table.

So instead of maintaining a 2D array, we track four essential states using variables:

  • firstBuy → the maximum profit after the first buy (we spend money, so it’s negative)
  • firstSell → the maximum profit after selling the first stock
  • secondBuy → the maximum profit after buying the second stock (using profit from the first sell)
  • secondSell → the maximum profit after the second sell

We iterate through each day’s price and update these states in sequence:

firstBuy = max(firstBuy, -price)
choose between keeping the previous buy or buying today’s stock
firstSell = max(firstSell, firstBuy + price)
choose between keeping the previous sell or selling today’s stock
secondBuy = max(secondBuy, firstSell - price)
choose between keeping the previous second buy or buying today after the first sell
secondSell = max(secondSell, secondBuy + price)
choose between keeping the previous second sell or selling today

Each step builds upon the previous one — simulating two complete transactions in constant space. Finally, secondSell holds the maximum achievable profit after at most two transactions.

C++ 
//Driver Code Starts
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
//Driver Code Ends


int maxProfit(vector<int> &prices) {
    
    // Variables to store the maximum profit 
    // after the first and second transactions
    int firstBuy = INT_MIN;  
    int firstSell = 0;      
    int secondBuy = INT_MIN; 
    int secondSell = 0;      
    
    // Iterate over each day's stock prices
    for (int i = 0; i < prices.size(); i++) {

        firstBuy = max(firstBuy, -prices[i]);
        firstSell = max(firstSell, firstBuy + prices[i]);
        secondBuy = max(secondBuy, firstSell - prices[i]);
        secondSell = max(secondSell, secondBuy + prices[i]);
    }
    
    // The result is the maximum 
    // profit after the second sell
    return secondSell;
}


//Driver Code Starts
int main() {
    vector<int> prices = { 10, 22, 5, 75, 65, 80 };
    cout << maxProfit(prices);
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
class GFG {
//Driver Code Ends


    static int maxProfit(int[] prices) {
        
        // Variables to store the maximum profit 
        // after the first and second transactions
        int firstBuy = Integer.MIN_VALUE;  
        int firstSell = 0;      
        int secondBuy = Integer.MIN_VALUE; 
        int secondSell = 0;      
        
        // Iterate over each day's stock prices
        for (int i = 0; i < prices.length; i++) {
            
            // Calculate maximum profit
            firstBuy = Math.max(firstBuy, -prices[i]);
            firstSell = Math.max(firstSell, firstBuy + prices[i]);
            secondBuy = Math.max(secondBuy, firstSell - prices[i]);
            secondSell = Math.max(secondSell, secondBuy + prices[i]);
        }
        
        // The result is the maximum 
        // profit after the second sell
        return secondSell;
    }


//Driver Code Starts
    public static void main(String[] args) {
        int[] prices = { 10, 22, 5, 75, 65, 80 };
        System.out.println(maxProfit(prices));
    }
}

//Driver Code Ends
Python 
def maxProfit(prices):
    
    # Variables to store the maximum profit 
    # after the first and second transactions
    firstBuy = float('-inf')  
    firstSell = 0      
    secondBuy = float('-inf') 
    secondSell = 0      
    
    # Iterate over each day's stock prices
    for i in range(len(prices)):
        
        # Calculate maximum profit
        firstBuy = max(firstBuy, -prices[i])
        firstSell = max(firstSell, firstBuy + prices[i])
        secondBuy = max(secondBuy, firstSell - prices[i])
        secondSell = max(secondSell, secondBuy + prices[i])
    
    # The result is the maximum 
    # profit after the second sell
    return secondSell


if __name__ == "__main__":
#Driver Code Starts
    prices = [10, 22, 5, 75, 65, 80]
    print(maxProfit(prices))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

class GFG {
//Driver Code Ends


    static int maxProfit(int[] prices) {
        
        // Variables to store the maximum profit 
        // after the first and second transactions
        int firstBuy = int.MinValue;  
        int firstSell = 0;      
        int secondBuy = int.MinValue; 
        int secondSell = 0;      
        
        // Iterate over each day's stock prices
        for (int i = 0; i < prices.Length; i++) {
            
            // Calculate maximum profit 
            firstBuy = Math.Max(firstBuy, -prices[i]);
            firstSell = Math.Max(firstSell, firstBuy + prices[i]);
            secondBuy = Math.Max(secondBuy, firstSell - prices[i]);
            secondSell = Math.Max(secondSell, secondBuy + prices[i]);
        }
        
        // The result is the maximum 
        // profit after the second sell
        return secondSell;
    }


//Driver Code Starts
    static void Main() {
        int[] prices = { 10, 22, 5, 75, 65, 80 };
        Console.WriteLine(maxProfit(prices));
    }
}

//Driver Code Ends
JavaScript 
function maxProfit(prices) {
    
    // Variables to store the maximum profit 
    // after the first and second transactions
    let firstBuy = -Infinity;  
    let firstSell = 0;      
    let secondBuy = -Infinity; 
    let secondSell = 0;      
    
    // Iterate over each day's stock price
    for (let i = 0; i < prices.length; i++) {
        
        // Calculate maximum profit
        firstBuy = Math.max(firstBuy, -prices[i]);
        firstSell = Math.max(firstSell, firstBuy + prices[i]);
        secondBuy = Math.max(secondBuy, firstSell - prices[i]);
        secondSell = Math.max(secondSell, secondBuy + prices[i]);
    }
    
    // The result is the maximum 
    // profit after the second sell
    return secondSell;
}


//Driver Code Starts
// Driver Code
let prices = [10, 22, 5, 75, 65, 80];
console.log(maxProfit(prices));

//Driver Code Ends

Output
87


Comment
Article Tags:
Dynamic Programming
Mathematical
DSA

Explore