LeetCode 465. Optimal Account Balancing

原题网址：https://leetcode.com/problems/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:

1. A transaction will be given as a tuple (x, y, z). Note that x ≠ y and z > 0.
2. 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.

方法：用银行结算的思路，首先计算出每个人的最后盈亏，然后用随机的算法找到比较可能的最小值。

参考：https://discuss.leetcode.com/topic/68948/easy-java-solution-with-explanation

public class Solution {
    public int minTransfers(int[][] transactions) {
        Map balances = new HashMap<>();
        for(int[] tran: transactions) {
            balances.put(tran[0], balances.getOrDefault(tran[0], 0) - tran[2]);
            balances.put(tran[1], balances.getOrDefault(tran[1], 0) + tran[2]);
        }
        List poss = new ArrayList<>();
        List negs = new ArrayList<>();
        for(Map.Entry balance : balances.entrySet()) {
            int val = balance.getValue();
            if (val > 0) poss.add(val);
            else if (val < 0) negs.add(-val);
        }
        int min = Integer.MAX_VALUE;
        Stack ps = new Stack<>();
        Stack ns = new Stack<>();
        for(int i = 0; i < 10; i++) {
            for(int pos: poss) {
                ps.push(pos);
            }
            for(int neg: negs) {
                ns.push(neg);
            }
            int count = 0;
            while (!ps.isEmpty()) {
                int p = ps.pop();
                int n = ns.pop();
                if (p > n) {
                    ps.push(p - n);
                } else if (p < n) {
                    ns.push(n - p);
                }
                count++;
            }
            min = Math.min(min, count);
            Collections.shuffle(poss);
            Collections.shuffle(negs);
        }
        return min;
    }
}