Minimum Money Required Before Transactions

Minimum Money Required Before Transactions - Problem

You are given a 0-indexed 2D integer array transactions, where transactions[i] = [cost_i, cashback_i].

The array describes transactions, where each transaction must be completed exactly once in some order. At any given moment, you have a certain amount of money. In order to complete transaction i, money >= cost_i must hold true. After performing a transaction, money becomes money - cost_i + cashback_i.

Return the minimum amount of money required before any transaction so that all of the transactions can be completed regardless of the order of the transactions.

Input & Output

Example 1 — Mixed Transactions

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

› Output: 10

💡 Note: One optimal order: [5,0] costs 5, [4,2] costs 4 but we have 0-5+0 = -5 so need 4-(-5) = 9 more, then [2,1]. Total initial money needed: 5 + 9 = 14. Actually, better order gives 10.

Example 2 — All Profitable

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

› Output: 3

💡 Note: Start with [3,5]: need 3 initially. After: 3-3+5 = 5. Then [0,3]: need 0, have 5. Final money needed: 3.

Example 3 — All Losses

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

› Output: 7

💡 Note: Do cheaper loss first: [4,1] needs 4 initially, left with 4-4+1=1. Then [7,0] needs 7, have 1, so need 6 more. Total: 4+6=10. Better: [7,0] first needs 7, then [4,1] needs 3 more since we have 0. Total: 7+3=10. Actually optimal gives 7.

Constraints

1 ≤ transactions.length ≤ 10⁵
transactions[i].length == 2
0 ≤ cost_i, cashback_i ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to separate transactions into profitable (cashback ≥ cost) and loss-making groups, then process them optimally: loss transactions in ascending order of cost, profitable transactions in descending order of net loss. Best approach is Greedy Strategy. Time: O(n log n), Space: O(n)

Common Approaches

✓ Greedy Optimal Strategy

⏱️ Time: O(n log n) Space: O(n)

Split transactions into profitable (cashback >= cost) and loss-making ones. Handle loss transactions first in ascending order of cost, then profitable ones in descending order of net loss to minimize peak money requirement.

Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

For each permutation of transactions, simulate the process and track the maximum money needed at any point. Return the minimum across all permutations.

Greedy Optimal Strategy — Algorithm Steps

Separate transactions into profitable and loss-making groups
Sort loss transactions by cost ascending, profitable by net loss descending
Calculate money needed for optimal ordering

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate Groups

Split into profitable and loss-making transactions

Sort Optimally

Loss by cost↑, profitable by net-loss↓

Calculate Money

Process in optimal order to find minimum

Code -

solution.c — C

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

typedef struct {
    int cost;
    int cashback;
    int index;
} Transaction;

int compareLoss(const void* a, const void* b) {
    Transaction* ta = (Transaction*)a;
    Transaction* tb = (Transaction*)b;
    return ta->cost - tb->cost;
}

int compareProfitable(const void* a, const void* b) {
    Transaction* ta = (Transaction*)a;
    Transaction* tb = (Transaction*)b;
    return ta->cost - tb->cost;
}

long long solution(int transactions[][2], int n) {
    static Transaction profitable[100000], loss[100000];
    int pCount = 0, lCount = 0;
    
    // Separate transactions
    for (int i = 0; i < n; i++) {
        int cost = transactions[i][0];
        int cashback = transactions[i][1];
        if (cashback >= cost) {
            profitable[pCount++] = (Transaction){cost, cashback, i};
        } else {
            loss[lCount++] = (Transaction){cost, cashback, i};
        }
    }
    
    // Sort arrays
    qsort(loss, lCount, sizeof(Transaction), compareLoss);
    qsort(profitable, pCount, sizeof(Transaction), compareProfitable);
    
    long long money = 0;
    long long maxMoney = 0;
    
    // Process loss transactions first
    for (int i = 0; i < lCount; i++) {
        long long cost = loss[i].cost;
        long long cashback = loss[i].cashback;
        if (money < cost) {
            maxMoney += cost - money;
            money = cost;
        }
        money = money - cost + cashback;
    }
    
    // Process profitable transactions
    for (int i = 0; i < pCount; i++) {
        long long cost = profitable[i].cost;
        long long cashback = profitable[i].cashback;
        if (money < cost) {
            maxMoney += cost - money;
            money = cost;
        }
        money = money - cost + cashback;
    }
    
    return maxMoney;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    static int transactions[100000][2];
    int n = 0;
    
    if (strstr(line, "[]")) {
        printf("0\n");
        return 0;
    }
    
    // Simple parsing for [[a,b],[c,d],...]
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            transactions[n][0] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            transactions[n][1] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr) ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    printf("%lld\n", solution(transactions, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting transactions dominates the time complexity

⚠ Quadratic Growth

Space Complexity

O(n)

Storing separated profitable and loss transaction lists

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

456 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

Greedy Optimal Strategy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler