##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2412.html

# 2412. Minimum Money Required Before Transactions

• Difficulty: Hard.
• Related Topics: .
• Similar Questions: .

## Problem

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

## Solution (Java, C++, Python)

• class Solution {
public long minimumMoney(int[][] transactions) {
Arrays.sort(transactions,(int a[],int b[])->(a-b));

long max=0,ans=0,ab=0;
for(int a[]:transactions){
if(a>a){
max+=a;
ans=Math.max(ans,max);
max-=a;
}
else ab=Math.max(ab,a);
}
ans=Math.max(ans,max+ab);
return ans;
}
}

############

class Solution {
public long minimumMoney(int[][] transactions) {
long s = 0;
for (var e : transactions) {
s += Math.max(0, e - e);
}
long ans = 0;
for (var e : transactions) {
if (e > e) {
ans = Math.max(ans, s + e);
} else {
ans = Math.max(ans, s + e);
}
}
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

############

# 2412. Minimum Money Required Before Transactions
# https://leetcode.com/problems/minimum-money-required-before-transactions

class Solution:
def minimumMoney(self, A: List[List[int]]) -> int:
return sum(max(0, i - j) for i, j in A) + max(map(min, A))


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

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

func max(a, b int) int {
if a > b {
return a
}
return b
}


Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).