Best Time to Buy and Sell Stock with Cooldown

Best Time to Buy and Sell Stock with Cooldown - Problem

Imagine you're a stock trader with access to future price information, but there's a catch - every time you sell stock, you must take a mandatory one-day vacation (cooldown period) before you can buy again!

Given an array prices where prices[i] represents the stock price on day i, your goal is to maximize your profit by strategically buying and selling shares.

Trading Rules:

🔄 You can complete unlimited transactions (buy-sell pairs)
⏸️ After selling, you must wait one day before buying again
🚫 You cannot hold multiple shares simultaneously
💰 Each transaction consists of buying one share and later selling it

Example: If prices = [1,2,3,0,2], you could buy on day 0 (price=1), sell on day 2 (price=3), cooldown on day 3, buy on day 3 (price=0), and sell on day 4 (price=2) for a total profit of (3-1) + (2-0) = 4.

Input & Output

example_1.py — Basic Trading

$ Input: [1,2,3,0,2]

› Output: 3

💡 Note: Buy on day 0 (price=1), sell on day 2 (price=3), profit = 3-1 = 2. Then buy on day 3 (price=0), sell on day 4 (price=2), profit = 2-0 = 2. Total profit = 2 + 2 = 4. Wait, that's wrong - we need cooldown! Correct: Buy day 0 (price=1), sell day 2 (price=3), cooldown day 3, buy day 4 would be invalid. Optimal: buy day 0, sell day 1 (profit=1), cooldown day 2, buy day 3, sell day 4 (profit=2). Total = 3.

example_2.py — No Profit Scenario

$ Input: [1]

› Output: 0

💡 Note: Only one day, so no transactions possible. Maximum profit is 0.

example_3.py — Declining Prices

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

› Output: 0

💡 Note: Prices are continuously declining, so buying any day and selling later would result in loss. Best strategy is to not trade at all, profit = 0.

Visualization

Tap to expand

Understanding the Visualization

Start in REST state

Day 0: We can buy stock, transitioning to HELD state

HELD state decisions

Each day: Hold stock or sell (go to SOLD state)

SOLD state cooldown

Must go to REST state next day (mandatory cooldown)

REST state options

Can stay in REST or buy stock (go to HELD)

Track maximum profit

For each state, keep the maximum profit achievable

Key Takeaway

🎯 Key Insight: Model the problem as a state machine with three states (HELD, SOLD, REST) and track the maximum profit achievable in each state at every day.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the prices array

✓ Linear Growth

Space Complexity

O(1)

Only storing three state variables

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 5000
0 ≤ prices[i] ≤ 1000
Cooldown constraint: After selling, must wait one day before buying
No simultaneous transactions: Must sell before buying again

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming with a state machine approach. We track three states: HELD (owning stock), SOLD (just sold, cooling down), and REST (ready to buy). The key insight is that at each day, we update these states based on the most profitable action from the previous day, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-up Optimal)	O(n)	O(1)	Iteratively track three states: held, sold, rest for maximum profit
Memoized Recursion (Top-down DP)	O(n)	O(n)	Cache recursive results to avoid redundant calculations
Brute Force (Try All Combinations)	O(3^n)	O(n)	Recursively try all possible buy/sell/cooldown combinations

Dynamic Programming (Bottom-up Optimal) — Algorithm Steps

Define three states: held (own stock), sold (just sold, cooling down), rest (ready to buy)
Initialize: held = -prices[0], sold = 0, rest = 0
For each day, update states based on previous day's optimal choices
Final answer is maximum of sold and rest states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize states

held = -prices[0], sold = 0, rest = 0

Update held

Max of keeping stock or buying from rest state

Update sold

Sell stock from held state

Update rest

Max of staying rest or finishing cooldown

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

int maxProfit(int* prices, int size) {
    if (size <= 1) {
        return 0;
    }
    
    int held = -prices[0];
    int sold = 0;
    int rest = 0;
    
    for (int i = 1; i < size; i++) {
        int prevHeld = held;
        int prevSold = sold;
        int prevRest = rest;
        
        held = max(prevHeld, prevRest - prices[i]);
        sold = prevHeld + prices[i];
        rest = max(prevRest, prevSold);
    }
    
    return max(sold, rest);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int prices[100];
    int size = 0;
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        prices[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maxProfit(prices, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the prices array

✓ Linear Growth

Space Complexity

O(1)

Only storing three state variables

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 5000
0 ≤ prices[i] ≤ 1000
Cooldown constraint: After selling, must wait one day before buying
No simultaneous transactions: Must sell before buying again

73.0K Views

High Frequency

~25 min Avg. Time

1.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 (Bottom-up Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler