add 465

Author: fishercoder1534

README.md

@@ -153,6 +153,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |468|[Validate IP Address](https://leetcode.com/problems/validate-ip-address/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_468.java) | O(n) |O(1) | Medium | String
 |467|[Unique Substrings in Wraparound String](https://leetcode.com/problems/unique-substrings-in-wraparound-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_467.java) | O(n) |O(1) | Medium| DP
 |466|[Count The Repetitions](https://leetcode.com/problems/count-the-repetitions/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_466.java)| O(max(m,n))|O(1) | Hard| DP
+|465|[Optimal Account Balancing](https://leetcode.com/problems/optimal-account-balancing/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_465.java)| | | Hard| DP
 |464|[Can I Win](https://leetcode.com/problems/can-i-win/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_464.java)| O(2^n)|O(n) | Medium| DP
 |463|[Island Perimeter](https://leetcode.com/problems/island-perimeter/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_463.java)| O(m*n)|O(1) | Easy| 
 |462|[Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_462.java) | O(nlogn) |O(1) | Medium|

src/main/java/com/fishercoder/solutions/_465.java

@@ -0,0 +1,93 @@
+package com.fishercoder.solutions;
+
+import java.util.*;
+
+/**
+ * 465. Optimal Account Balancing
+ *
+ * A group of friends went on holiday and sometimes lent each other money.
+ * For example, Alice paid for Bill's lunch for $10.
+ * Then later Chris gave Alice $5 for a taxi ride.
+ * We can model each transaction as a tuple (x, y, z) which means person x gave person y $z.
+ * Assuming Alice, Bill, and Chris are person 0, 1, and 2 respectively (0, 1, 2 are the person's ID),
+ * the transactions can be represented as [[0, 1, 10], [2, 0, 5]].
+
+ Given a list of transactions between a group of people, return the minimum number of transactions required to settle the debt.
+
+ Note:
+
+ A transaction will be given as a tuple (x, y, z). Note that x ? y and z > 0.
+ Person's IDs may not be linear, e.g. we could have the persons 0, 1, 2 or we could also have the persons 0, 2, 6.
+ Example 1:
+
+ Input:
+ [[0,1,10], [2,0,5]]
+
+ Output:
+ 2
+
+ Explanation:
+ Person #0 gave person #1 $10.
+ Person #2 gave person #0 $5.
+
+ Two transactions are needed. One way to settle the debt is person #1 pays person #0 and #2 $5 each.
+ Example 2:
+
+ Input:
+ [[0,1,10], [1,0,1], [1,2,5], [2,0,5]]
+
+ Output:
+ 1
+
+ Explanation:
+ Person #0 gave person #1 $10.
+ Person #1 gave person #0 $1.
+ Person #1 gave person #2 $5.
+ Person #2 gave person #0 $5.
+
+ Therefore, person #1 only need to give person #0 $4, and all debt is settled.
+ */
+public class _465 {
+    /**Reference: https://discuss.leetcode.com/topic/68948/easy-java-solution-with-explanation*/
+    public int minTransfers(int[][] transactions) {
+        if (transactions == null || transactions.length == 0) return 0;
+        Map<Integer, Integer> acc = new HashMap<>();
+        for (int i = 0; i < transactions.length; i++) {
+            int id1 = transactions[i][0];
+            int id2 = transactions[i][1];
+            int m = transactions[i][2];
+            acc.put(id1, acc.getOrDefault(id1, 0) - m);
+            acc.put(id2, acc.getOrDefault(id2, 0) + m);
+        }
+        List<Integer> negs = new ArrayList<>();
+        List<Integer> poss = new ArrayList<>();
+        for (Integer key : acc.keySet()) {
+            int m = acc.get(key);
+            if (m == 0) continue;
+            if (m < 0) negs.add(-m);
+            else poss.add(m);
+        }
+        int ans = Integer.MAX_VALUE;
+        Stack<Integer> stNeg = new Stack<>(), stPos = new Stack<>();
+        for (int i = 0; i < 1000; i++) {
+            for (Integer num : negs) stNeg.push(num);
+            for (Integer num : poss) stPos.push(num);
+            int cur = 0;
+            while (!stNeg.isEmpty()) {
+                int n = stNeg.pop();
+                int p = stPos.pop();
+                cur++;
+                if (n == p) continue;
+                if (n > p) {
+                    stNeg.push(n - p);
+                } else {
+                    stPos.push(p - n);
+                }
+            }
+            ans = Math.min(ans, cur);
+            Collections.shuffle(negs);
+            Collections.shuffle(poss);
+        }
+        return ans;
+    }
+}