Update Backtracking/465_Optimal_Account_Balancing.java

Author: seanprashad

Backtracking/465_Optimal_Account_Balancing.java

@@ -1,47 +1,49 @@
 class Solution {
     public int minTransfers(int[][] transactions) {
-        Map<Integer, Integer> balances = new HashMap<>();
+        Map<Integer, Integer> balanceMap = new HashMap<>();
 
         for (int[] transaction : transactions) {
             int from = transaction[0];
             int to = transaction[1];
             int amount = transaction[2];
-            
-            balances.put(from, balances.getOrDefault(from, 0) - amount);
-            balances.put(to, balances.getOrDefault(to, 0) + amount);
+
+            balanceMap.put(from, balanceMap.getOrDefault(from, 0) - amount);
+            balanceMap.put(to, balanceMap.getOrDefault(to, 0) + amount);
         }
 
         int idx = 0;
-        int[] debts = new int[balances.size()];
+        int[] balances = new int[balanceMap.size()];
 
-        for (int debt : balances.values()) {
-            debts[idx] = debt;
+        for (int balance : balanceMap.values()) {
+            balances[idx] = balance;
             ++idx;
         }
 
-        return dfs(debts, 0);
+        return minTransfersHelper(balances, 0);
     }
 
-    private int dfs(int[] balances, int start) {
-        if (start == balances.length) {
-            return 0;
-        }
+    private int minTransfersHelper(int[] balances, int idx) {
+        if (idx == balances.length) { return 0; }
 
-        if (balances[start] == 0) {
-            return dfs(balances, start + 1);
+        if (balances[idx] == 0) {
+            return minTransfersHelper(balances, idx + 1);
         }
 
-        int minTransactions = Integer.MAX_VALUE;
-        int currBalance = balances[start];
+        int currBalance = balances[idx];
+        int minNumberOfTransactions = Integer.MAX_VALUE;
 
-        for (int i = start + 1; i < balances.length; i++) {
-            if (currBalance * balances[i] >= 0) { continue; }
+        for (int i = idx + 1; i < balances.length; i++) {
+            // Case 1: Both positive values - redundant to offset balance
+            // Case 2: Both negative values - redundant to give even more debt
+            if (currBalance * balances[i] >= 0) {
+                continue;
+            }
 
             balances[i] += currBalance;
-            minTransactions = Math.min(minTransactions, 1 + dfs(balances, start + 1));
+            minNumberOfTransactions = Math.min(minNumberOfTransactions, 1 + minTransfersHelper(balances, idx + 1));
             balances[i] -= currBalance;
         }
 
-        return minTransactions;
+        return minNumberOfTransactions;
     }
 }