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
andz > 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.
Accepted
32,715
Submissions
70,489
--------------------------------------------------------------------
思路一:非常好的一道題目,直接的解法就是回溯。A總算賬多錢,B總算賬少錢;或者A總算賬少錢,B總算賬多錢。可以通過B把A的帳清了,A就回溯完了,B和其他人的賬號後面dfs再算。。。
class Solution {
public:
int minTransfers(vector<vector<int>>& transactions) {
int res = INT_MAX;
unordered_map<int, int> m;
for (auto t : transactions) {
m[t[0]] -= t[2];
m[t[1]] += t[2];
}
vector<int> accnt;
for (auto a : m) {
if (a.second != 0) accnt.push_back(a.second);
}
helper(accnt, 0, 0, res);
return res;
}
void helper(vector<int>& accnt, int start, int cnt, int& res) {
int n = accnt.size();
while (start < n && accnt[start] == 0) ++start;
if (cnt >= res) {
return;
}
if (start == n) {
res = min(res, cnt);
return;
}
for (int i = start + 1; i < n; ++i) {
if ((accnt[i] < 0 && accnt[start] > 0) || (accnt[i] > 0 && accnt[start] < 0)) {
accnt[i] += accnt[start];
helper(accnt, start + 1, cnt + 1, res);
accnt[i] -= accnt[start];
}
}
}
};
思路二:最差情況下,所有人總算賬都要付錢或者拿錢,家裏打麻將結賬就是這麼算錢的,每個人考慮自己的多少,把錢扔到公共的buffer裏,這是人的總數N。如果這N箇中最多包含m個和爲0的子團(m肯定至少爲1呀),那麼最終結果就是N-m。這個問題還可以從另外一個角度去想:假設有10個人,5個人是一團爲0,需要4,另外5個人一團爲0,也需要4,每出現一個團就可能爲最終結果-1。所以問題就變成了求m,動態規劃就可以了,當然這個動態規劃的遞推邏輯並不容易想。
注意這裏組合數遍歷的方式和24點(https://blog.csdn.net/taoqick/article/details/23393487)的方式不同:
from collections import defaultdict
class Solution:
def minTransfers(self, transactions):
money = defaultdict(int)
for sender, receiver, amount in transactions:
money[sender] -= amount
money[receiver] += amount
amounts = [amount for amount in money.values() if amount != 0]
N = len(amounts)
dp = [0] * (2 ** N) #dp[i]表示最多以組合i的結果最多包含幾個和爲0的團
sums = [0] * (2 ** N) # sums[i]表示以組合i的結果累加和是多少
for mask in range(2 ** N):
set_bit = 1
for b in range(N):
if mask & set_bit == 0:
nxt = mask | set_bit
sums[nxt] = sums[mask] + amounts[b]
if sums[nxt] == 0:
dp[nxt] = max(dp[nxt], dp[mask] + 1)
else:
dp[nxt] = max(dp[nxt], dp[mask])
set_bit <<= 1
return N - dp[-1]
s = Solution()
print(s.minTransfers([[0,1,5], [0,2,6], [0,3,6]]))