LeetCode 2412. Minimum Money Required Before Transactions Solution in Java, C++, Python & More | Explanation + Code

Description

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

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 >= costi must hold true. After performing a transaction, money becomes money - costi + cashbacki.

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 <= 105
• transactions[i].length == 2
• 0 <= costi, cashbacki <= 109

Solutions

Solution 1: Greedy

First, we accumulate all negative profits, denoted as s. Then, we enumerate each transaction transactions[i] = [a, b] as the last transaction. If a > b, it means the current transaction is a loss, and this transaction has already been included when we accumulated the negative profits earlier. Therefore, we update the answer with s + b. Otherwise, we update the answer with s + a.

The time complexity is O(n), where n is the number of transactions. The space complexity is O(1).

PythonJavaC++GoTypeScriptRustJavaScript

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(code-box)

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; } }(code-box)

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; } };(code-box)

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) }(code-box)

function minimumMoney(transactions: number[][]): number { const s = transactions.reduce((acc, [a, b]) => acc + Math.max(0, a - b), 0); let ans = 0; for (const [a, b] of transactions) { if (a > b) { ans = Math.max(ans, s + b); } else { ans = Math.max(ans, s + a); } } return ans; }(code-box)

impl Solution { pub fn minimum_money(transactions: Vec<Vec<i32>>) -> i64 { let mut s: i64 = 0; for transaction in &transactions { let (a, b) = (transaction[0], transaction[1]); s += (a - b).max(0) as i64; } let mut ans = 0; for transaction in &transactions { let (a, b) = (transaction[0], transaction[1]); if a > b { ans = ans.max(s + b as i64); } else { ans = ans.max(s + a as i64); } } ans } }(code-box)

/** * @param {number[][]} transactions * @return {number} */ var minimumMoney = function (transactions) { const s = transactions.reduce((acc, [a, b]) => acc + Math.max(0, a - b), 0); let ans = 0; for (const [a, b] of transactions) { if (a > b) { ans = Math.max(ans, s + b); } else { ans = Math.max(ans, s + a); } } return ans; };(code-box)