Welcome to Subscribe On Youtube
2412. Minimum Money Required Before Transactions
Description
You are given a 0indexed 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.
Example 1:
Input: transactions = [[2,1],[5,0],[4,2]] Output: 10 Explanation: Starting with money = 10, the transactions can be performed in any order. It can be shown that starting with money < 10 will fail to complete all transactions in some order.
Example 2:
Input: transactions = [[3,0],[0,3]] Output: 3 Explanation:  If transactions are in the order [[3,0],[0,3]], the minimum money required to complete the transactions is 3.  If transactions are in the order [[0,3],[3,0]], the minimum money required to complete the transactions is 0. Thus, starting with money = 3, the transactions can be performed in any order.
Constraints:
1 <= transactions.length <= 10^{5}
transactions[i].length == 2
0 <= cost_{i}, cashback_{i} <= 10^{9}
Solutions
Solution 1: Greedy
First, we accumulate all the negative profits, denoted as $s$. Then we enumerate each transaction as the last transaction. If transactions[i].x > transactions[i].y
, it means the current transaction is losing money, and this transaction has been calculated when we previously accumulated negative profits, so we update the answer with s + transactions[i].y
; otherwise, we update the answer with s + transactions[i].x
.
The time complexity is $O(n)$, where $n$ is the number of transactions. The space complexity is $O(1)$.

class Solution { public long minimumMoney(int[][] transactions) { long s = 0; for (var e : transactions) { s += Math.max(0, e[0]  e[1]); } long ans = 0; for (var e : transactions) { if (e[0] > e[1]) { ans = Math.max(ans, s + e[1]); } else { ans = Math.max(ans, s + e[0]); } } return ans; } }

class Solution { public: long long minimumMoney(vector<vector<int>>& transactions) { long long s = 0, ans = 0; for (auto& e : transactions) { s += max(0, e[0]  e[1]); } for (auto& e : transactions) { if (e[0] > e[1]) { ans = max(ans, s + e[1]); } else { ans = max(ans, s + e[0]); } } return ans; } };

class Solution: def minimumMoney(self, transactions: List[List[int]]) > int: s = sum(max(0, a  b) for a, b in transactions) ans = 0 for a, b in transactions: if a > b: ans = max(ans, s + b) else: ans = max(ans, s + a) return ans

func minimumMoney(transactions [][]int) int64 { s, ans := 0, 0 for _, e := range transactions { s += max(0, e[0]e[1]) } for _, e := range transactions { if e[0] > e[1] { ans = max(ans, s+e[1]) } else { ans = max(ans, s+e[0]) } } return int64(ans) }