Best Time to Buy and Sell Stock with Transaction Fee

Best Time to Buy and Sell Stock with Transaction Fee - Problem

You're a savvy day trader looking to maximize profits in the stock market! 📈

Given an array prices where prices[i] represents the stock price on day i, and a fee charged for each transaction, find the maximum profit you can achieve.

Trading Rules:

You can complete unlimited transactions (buy and sell multiple times)
You must sell before buying again (no simultaneous holdings)
Each complete transaction (buy + sell) incurs a fee
The fee is charged once per complete transaction

Goal: Determine the maximum profit possible after all trading fees are deducted.

Example: If prices = [1,3,2,8,4,9] and fee = 2, you could buy at 1, sell at 8 (profit: 8-1-2=5), then buy at 4, sell at 9 (profit: 9-4-2=3), for total profit of 8.

Input & Output

example_1.py — Basic Case

$ Input: prices = [1,3,2,8,4,9], fee = 2

› Output: 8

💡 Note: Buy at price 1, sell at price 8 (profit: 8-1-2 = 5). Then buy at price 4, sell at price 9 (profit: 9-4-2 = 3). Total profit = 5 + 3 = 8.

example_2.py — High Fees

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

› Output: 6

💡 Note: Buy at price 1, sell at price 10 (profit: 10-1-3 = 6). Other transactions would not be profitable due to the high fee.

example_3.py — No Profit Case

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

› Output: 0

💡 Note: The transaction fee (5) is higher than any possible profit from buying and selling, so it's better not to trade at all.

Visualization

Tap to expand

Understanding the Visualization

Two States

Track maximum profit in two states: holding stock vs not holding stock

Daily Decisions

Each day, decide whether to buy, sell, or hold based on current price and fee

State Transitions

Update states: hold = max(keep holding, buy today), sold = max(stay sold, sell today - fee)

Optimal Result

Final answer is 'sold' state since we want to end without holding stock

Key Takeaway

🎯 Key Insight: Track two states (holding vs not holding) and transition optimally each day to maximize profit while accounting for transaction fees

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each state (day, holding) computed once, and there are 2n total states

✓ Linear Growth

Space Complexity

O(n)

Memoization table plus recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ prices.length ≤ 5 × 10⁴
1 ≤ prices[i] ≤ 5 × 10⁴
0 ≤ fee ≤ 5 × 10⁴
All prices and fees are non-negative integers

Asked in

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

The optimal solution uses iterative dynamic programming with two state variables: hold (max profit when holding stock) and sold (max profit when not holding stock). At each day, we update both states by considering whether to buy, sell, or do nothing, always keeping the maximum profit for each state. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized Recursion)	O(n)	O(n)	Optimize brute force by caching subproblem results
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible buy-sell combination and find maximum profit
Iterative Dynamic Programming (Optimal)	O(n)	O(1)	Bottom-up DP tracking two states: holding stock vs not holding

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Define state as (day, holding_stock)
Use memoization to cache results for each state
At each day, decide whether to buy, sell, or hold
Return cached result if already computed

Visualization

Tap to expand

Step-by-Step Walkthrough

Define States

Each state is (day, holding_stock) with maximum profit from that point

Cache Results

Store computed results to avoid recalculation

Reuse Cache

When the same state is encountered, return cached value

Linear Time

Each state computed once, giving O(n) complexity

Code -

solution.c — C

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

#define MAXN 50000
int memo[MAXN][2];
int visited[MAXN][2];

int dp(int* prices, int len, int fee, int day, int holding) {
    if (day >= len) return 0;
    
    if (visited[day][holding]) return memo[day][holding];
    
    // Option 1: Do nothing today
    int result = dp(prices, len, fee, day + 1, holding);
    
    if (holding) {
        // Option 2: Sell today
        int sellResult = prices[day] - fee + dp(prices, len, fee, day + 1, 0);
        if (sellResult > result) result = sellResult;
    } else {
        // Option 2: Buy today
        int buyResult = -prices[day] + dp(prices, len, fee, day + 1, 1);
        if (buyResult > result) result = buyResult;
    }
    
    visited[day][holding] = 1;
    memo[day][holding] = result;
    return result;
}

int maxProfit(int* prices, int len, int fee) {
    memset(visited, 0, sizeof(visited));
    return dp(prices, len, fee, 0, 0);
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int prices[MAXN];
    int len = 0;
    char* token = strtok(line, ",");
    while (token != NULL) {
        prices[len++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    int fee;
    scanf("%d", &fee);
    
    printf("%d\n", maxProfit(prices, len, fee));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each state (day, holding) computed once, and there are 2n total states

✓ Linear Growth

Space Complexity

O(n)

Memoization table plus recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ prices.length ≤ 5 × 10⁴
1 ≤ prices[i] ≤ 5 × 10⁴
0 ≤ fee ≤ 5 × 10⁴
All prices and fees are non-negative integers

67.2K 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 (Memoized Recursion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler