LeetCode 465. Optimal Account Balancing

最新推荐文章于 2023-01-17 18:09:29 发布

原创最新推荐文章于 2023-01-17 18:09:29 发布 · 3.7k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

困难同时被 3 个专栏收录

37 篇文章

订阅专栏

结算

1 篇文章

订阅专栏

借贷

1 篇文章

订阅专栏

这是一篇关于LeetCode第465题的博客，题目涉及朋友间的金钱借贷。每个交易由(x, y, z)表示，x给了y z元。目标是找出最少的交易次数来结算所有债务。文章提供了一个示例及一种利用类似银行结算的方法来求解问题的思路，并引用了相关讨论论坛的链接作为参考。" 111705901,10295605,Python MQTT连接阿里物联网平台：物联网通讯详解,"['物联网开发', 'MQTT协议', 'Python编程', '阿里云', '嵌入式通信']

原题网址：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:

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.

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

参考：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;
    }
}