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:2Explanation: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:1Explanation: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<Integer, Integer> 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<Integer> poss = new ArrayList<>();        List<Integer> negs = new ArrayList<>();        for(Map.Entry<Integer, Integer> 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<Integer> ps = new Stack<>();        Stack<Integer> 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;    }}