LeetCode 465. Optimal Account Balancing

原题链接在这里：https://leetcode.com/problems/optimal-account-balancing/

题目：

You are given an array of transactions transactions where transactions[i] = [fromi, toi, amounti] indicates that the person with ID = fromi gave amounti $ to the person with ID = toi.

Return the minimum number of transactions required to settle the debt.

Example 1:

Input: transactions = [[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: transactions = [[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.

Constraints:

• 1 <= transactions.length <= 8
• transactions[i].length == 3
• 0 <= fromi, toi < 12
• fromi != toi
• 1 <= amounti <= 100

题解：

For each transaction, it could create debt between two ppl.

We want to clear all ppl's debt.

We first get the debt for each person.

Any person's debt * debt[start] < 0 could help clear start's debt.

DFS state includes debt list, start person index.

Thinking 1 transaction cleared person start. Then the reset would be dfs(start + 1, debt).

Time Compexity: O(n!). T(n) = n * T(n - 1). n = transactions.length. On the first level, i is in the loop between [start, n]. On the second level, j is in the loop between [start + 1, n]. ... On the bottom level, k is in the loop between [n - 1, n].

Space: O(n).

AC Java:

class Solution {
    public int minTransfers(int[][] transactions) {
        HashMap<Integer, Integer> hm = new HashMap<>();
        for(int [] t : transactions){
            hm.put(t[0], hm.getOrDefault(t[0], 0) - t[2]);
            hm.put(t[1], hm.getOrDefault(t[1], 0) + t[2]);
        }
        
        return dfs(0, new ArrayList<Integer>(hm.values()));
    }
    
    private int dfs(int start, ArrayList<Integer> debt){
        while(start < debt.size() && debt.get(start) == 0){
            start++;
        }
        
        if(start == debt.size()){
            return 0;
        }
        
        int res = Integer.MAX_VALUE;
        for(int i = start + 1; i < debt.size(); i++){
            if(debt.get(start) * debt.get(i) < 0){
                debt.set(i, debt.get(i) + debt.get(start));
                res = Math.min(res, 1 + dfs(start + 1, debt));
                debt.set(i, debt.get(i) - debt.get(start));
            }
        }
        
        return res;
    }
}