Minimum Money Required Before Transactions

Minimum Money Required Before Transactions - Problem

Imagine you're planning to complete a series of financial transactions, each with a cost upfront and a cashback afterward. The challenge? You need to determine the minimum starting amount that guarantees you can complete all transactions regardless of their order.

You are given a 2D array transactions where transactions[i] = [cost_i, cashback_i]. Each transaction must be completed exactly once, and at any moment, your money must be at least cost_i to perform transaction i. After completing it, your money becomes money - cost_i + cashback_i.

Goal: Return the minimum initial amount needed so that no matter how the transactions are ordered, you can always complete them all.

Example: If transactions = [[2,1],[5,0],[4,2]], you might need different starting amounts depending on the order. The answer is the minimum that works for any possible order.

Input & Output

example_1.py — Basic Case

$ Input: transactions = [[2,1],[5,0],[4,2]]

› Output: 10

💡 Note: One possible order: [5,0] first (need 5), then [4,2] (need 4, have 0 so need 4 more = 9 total), then [2,1] (need 2, have 2). Maximum needed was 9. However, with optimal ordering we can do better and need only 10 initially.

example_2.py — All Profitable

$ Input: transactions = [[3,5],[0,3]]

› Output: 3

💡 Note: Both transactions are profitable. We need at most 3 to start the first transaction [3,5], after which we'll have enough for any remaining transactions.

example_3.py — Edge Case

$ Input: transactions = [[7,0],[0,1]]

› Output: 7

💡 Note: The transaction [7,0] requires 7 initially and gives back nothing. We need at least 7 to complete all transactions regardless of order.

Constraints

1 ≤ transactions.length ≤ 10⁵
transactions[i].length == 2
0 ≤ cost_i, cashback_i ≤ 10⁹
Each transaction must be completed exactly once

Visualization

Tap to expand

Understanding the Visualization

Analyze Each Deal

Categorize each transaction as profitable (cashback ≥ cost) or loss-making (cashback < cost)

Strategic Ordering

Place loss-making deals first, ordered by biggest net loss first, to minimize capital requirements early

Simulate Execution

Track the maximum money needed during the entire sequence to find the minimum starting amount

Key Takeaway

🎯 Key Insight: By strategically ordering transactions (losses first, then profits), we minimize the peak capital requirement, solving this complex optimization problem with a simple greedy approach.

Asked in

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

The optimal approach uses a greedy strategy: separate transactions into profitable and loss-making categories, then execute loss-making transactions first (sorted by net loss descending) followed by profitable ones. This minimizes the peak capital requirement and runs in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Orders)	O(n! × n)	O(n)	Generate all possible transaction orders and simulate each one
Greedy Sorting Approach (Optimal)	O(n log n)	O(n)	Separate profitable and loss-making transactions, then order them optimally

Brute Force (Try All Orders) — Algorithm Steps

Generate all n! permutations of transactions
For each permutation, simulate the transaction sequence
Track the minimum money needed to complete all transactions in that order
Return the minimum across all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of transactions

Simulate Each Order

For each order, track money needed throughout

Find Minimum

Return the smallest starting amount needed

Code -

solution.c — C

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

long long simulateOrder(int** order, int n) {
    long long moneyNeeded = 0;
    long long currentMoney = 0;
    
    for (int i = 0; i < n; i++) {
        int cost = order[i][0];
        int cashback = order[i][1];
        
        if (currentMoney < cost) {
            long long needed = cost - currentMoney;
            moneyNeeded += needed;
            currentMoney += needed;
        }
        
        currentMoney = currentMoney - cost + cashback;
    }
    
    return moneyNeeded;
}

void permute(int** transactions, int n, int start, long long* minMoney) {
    if (start == n) {
        long long needed = simulateOrder(transactions, n);
        if (needed < *minMoney) {
            *minMoney = needed;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        // Swap
        int* temp = transactions[start];
        transactions[start] = transactions[i];
        transactions[i] = temp;
        
        permute(transactions, n, start + 1, minMoney);
        
        // Swap back
        temp = transactions[start];
        transactions[start] = transactions[i];
        transactions[i] = temp;
    }
}

long long minMoneyRequired(int** transactions, int n) {
    long long minMoney = LLONG_MAX;
    permute(transactions, n, 0, &minMoney);
    return minMoney;
}

int main() {
    int n = 3;
    int** transactions = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        transactions[i] = malloc(2 * sizeof(int));
    }
    
    transactions[0][0] = 2; transactions[0][1] = 1;
    transactions[1][0] = 5; transactions[1][1] = 0;
    transactions[2][0] = 4; transactions[2][1] = 2;
    
    printf("%lld\n", minMoneyRequired(transactions, n));
    
    for (int i = 0; i < n; i++) {
        free(transactions[i]);
    }
    free(transactions);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to simulate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and recursion stack

⚡ Linearithmic Space

28.4K Views

High Frequency

~25 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Orders) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler