Leetcode 465. Optimal Account Balancing

Problem:

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.

Solution:

　　这道题的要求我们在一堆账户中计算最少的转账次数使得所有账户余额都为0。一开始我还以为要用什么奇淫巧技，后来实在想不出来就尝试了下暴力解法，也就是DFS，结果就做出来了。这里有一个重要的优化的地方，就是每次转账必须要两个账户符号不同（想想也是，只有富人接济穷人，哪有富人接济富人或穷人接济穷人的道理），否则会超时。

Code:

 

class Solution {
public:
    void dfs(int index,int times,vector<int> &data,int &result){
        if(index == data.size()){
            result = min(result,times);
            return;
        }
        if(data[index] == 0)
            dfs(index+1,times,data,result);
        else if(data[index] > 0){
            for(int i = index+1;i != data.size();++i){
                if(data[i] < 0){
                    data[i] += data[index];
                    dfs(index+1,times+1,data,result);
                    data[i] -= data[index];
                }
            }
        }
        else{
            for(int i = index+1;i != data.size();++i){
                if(data[i] > 0){
                    data[i] += data[index];
                    dfs(index+1,times+1,data,result);
                    data[i] -= data[index];
                }
            }
        }
    }
    int minTransfers(vector<vector<int>>& transactions) {
        int m = transactions.size();
        unordered_map<int,int> um;
        for(int i = 0;i != m;++i){
            um[transactions[i][0]] -= transactions[i][2];
            um[transactions[i][1]] += transactions[i][2];
        }
        vector<int> data;
        for(auto iter:um){
            if(iter.second != 0)
                data.push_back(iter.second);
        }
        int result = INT_MAX;
        dfs(0,0,data,result);
        return result;
    }
};