Best Time to Buy and Sell Stock III - Practice Coding Problems

Best Time to Buy and Sell Stock III - Problem

You're a stock trader with a special constraint: you can only make at most two transactions (buy-sell pairs) to maximize your profit.

Given an array prices where prices[i] represents the stock price on day i, find the maximum profit you can achieve with at most 2 complete transactions.

Important Rules:

You must sell before buying again (no simultaneous transactions)
A transaction consists of buying and then selling one share
You can choose to make 0, 1, or 2 transactions

Example: If prices = [3,3,5,0,0,3,1,4], you can buy at 3, sell at 5 (profit=2), then buy at 0, sell at 4 (profit=4) for total profit of 6.

Input & Output

example_1.py — Basic Case

$ Input: prices = [3,3,5,0,0,3,1,4]

› Output: 6

💡 Note: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3. Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 3. Total profit = 6.

example_2.py — Single Transaction Better

$ Input: prices = [1,2,3,4,5]

› Output: 4

💡 Note: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 4. Making a second transaction would not increase profit.

example_3.py — No Profit Possible

$ Input: prices = [7,6,4,3,1]

› Output: 0

💡 Note: Prices only decrease, so no profitable transactions are possible.

Visualization

Tap to expand

Understanding the Visualization

Initialize States

Start with four states tracking maximum profit at each trading stage

Process Each Day

For each price, decide whether to transition states or maintain current position

State Updates

Update each state by choosing maximum between staying or taking action

Extract Result

Final result is in sell2 state, representing maximum profit from at most 2 complete transactions

Key Takeaway

🎯 Key Insight: We don't need to track all possible transaction combinations - just maintain the optimal profit for each trading state and transition between them optimally.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, updating four states at each step

✓ Linear Growth

Space Complexity

O(1)

Only using four variables to track the states

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
0 ≤ prices[i] ≤ 10⁵
At most 2 transactions allowed

Asked in

a Amazon 85 G Google 72 ⊞ Microsoft 64 f Meta 51 Apple 43

The optimal solution uses dynamic programming with state tracking. We maintain four states representing maximum profit after each trading stage: buy1, sell1, buy2, sell2. At each day, we update all states based on whether it's better to take action or stay in the current state. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (State Machine)	O(n)	O(1)	Track four states at each day: buy1, sell1, buy2, sell2 using dynamic programming

Dynamic Programming (State Machine) — Algorithm Steps

Initialize four states: buy1, sell1, buy2, sell2 with appropriate values
For each day, update all four states based on current price
buy1: max of previous buy1 or buying today (-price)
sell1: max of previous sell1 or selling after buy1 (buy1 + price)
buy2: max of previous buy2 or buying after sell1 (sell1 - price)
sell2: max of previous sell2 or selling after buy2 (buy2 + price)
Return sell2 as it represents maximum profit after at most 2 transactions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Set up four states with initial values

Process Each Day

Update all states based on current price

State Transitions

Each state can transition to the next or stay the same

Final Result

sell2 contains maximum profit from at most 2 transactions

Code -

solution.c — C

#include <stdio.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int maxProfit(int* prices, int pricesSize) {
    if (pricesSize == 0) return 0;
    
    int buy1 = -prices[0];
    int sell1 = 0;
    int buy2 = -prices[0];
    int sell2 = 0;
    
    for (int i = 1; i < pricesSize; i++) {
        int price = prices[i];
        sell2 = max(sell2, buy2 + price);
        buy2 = max(buy2, sell1 - price);
        sell1 = max(sell1, buy1 + price);
        buy1 = max(buy1, -price);
    }
    
    return sell2;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, updating four states at each step

✓ Linear Growth

Space Complexity

O(1)

Only using four variables to track the states

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
0 ≤ prices[i] ≤ 10⁵
At most 2 transactions allowed

68.3K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (State Machine) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler