Optimal Account Balancing - Practice Coding Problems

Optimal Account Balancing - Problem

Imagine you're managing a group expense tracking app where friends frequently lend money to each other. After a vacation or shared activities, you have a complex web of debts between people. Your task is to minimize the number of actual money transfers needed to settle all debts.

You are given an array of transactions transactions where transactions[i] = [from_i, to_i, amount_i] indicates that person with ID from_i gave amount_i dollars to person with ID to_i.

Goal: Return the minimum number of transactions required to settle all debts completely.

Example: If Alice owes Bob $10, Bob owes Charlie $10, instead of 2 separate transactions, Alice can pay Charlie directly - just 1 transaction!

Input & Output

example_1.py — Simple Triangle

$ Input: transactions = [[0,1,10],[2,0,5]]

› Output: 2

💡 Note: Person 0 gave $10 to person 1 and received $5 from person 2. Net: Person 0 owes $5, Person 1 is owed $10, Person 2 owes $5. Optimal: Person 0 pays Person 1 $5, Person 2 pays Person 1 $5. Total: 2 transactions.

example_2.py — Linear Chain

$ Input: transactions = [[0,1,10],[1,0,1],[1,2,5],[2,0,5]]

› Output: 1

💡 Note: After all transactions: Person 0 has net 0, Person 1 owes $4, Person 2 is owed $4. Only 1 transaction needed: Person 1 pays Person 2 $4.

example_3.py — Already Balanced

$ Input: transactions = [[0,1,5],[1,0,5]]

› Output: 0

💡 Note: All debts are already settled. Person 0 gave $5 to Person 1, then Person 1 gave $5 back to Person 0. No additional transactions needed.

Visualization

Tap to expand

Understanding the Visualization

Calculate Net Balances

First, we compute each person's net balance (money owed minus money to receive)

Identify Settlement Groups

Find groups of people whose balances sum to zero - they can settle among themselves

Apply DP Optimization

Use dynamic programming to find the minimum number of such groups

Calculate Transactions

Each group of size k needs exactly k-1 transactions to settle internally

Key Takeaway

🎯 Key Insight: We only care about net balances, not individual transactions. By finding groups of people whose net balances sum to zero, we can minimize the total number of settlement transactions needed.

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each subset, we iterate through all its subsets. Total is sum of C(n,k)*2^k = 3^n

✓ Linear Growth

Space Complexity

O(2^n)

DP array of size 2^n to store minimum groups for each bitmask

⚠ Quadratic Space

Constraints

1 ≤ transactions.length ≤ 8
transactions[i].length == 3
0 ≤ from_i, to_i < 12
from_i ≠ to_i
1 ≤ amount_i ≤ 100

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses bitmask dynamic programming to find minimum debt settlement. Key insight: we only need to track net balances and find groups where balances sum to zero. Each such group can settle internally with (group_size - 1) transactions. The DP approach efficiently explores all possible groupings in O(3^n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Bitmask Dynamic Programming	O(3^n)	O(2^n)	Use bitmask to represent groups of people and DP to find minimum partitions
Brute Force Backtracking	O(n!)	O(n)	Try all possible ways to settle debts using recursive backtracking

Bitmask Dynamic Programming — Algorithm Steps

Calculate net balance for each person, filter non-zero balances
Generate all possible subsets using bitmasks
Identify valid subsets where sum of balances equals zero
Use DP: for each mask, try all valid subsets and find minimum groups
Answer is DP[full_mask] where each group needs (group_size - 1) transactions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Balances

Person 0: -5, Person 1: +10, Person 2: -5

Find Valid Groups

Groups with sum=0: {0,1}, {0,2}, {1,2}, {0,1,2}

DP Computation

dp[011] = 1 (persons 0,1 form 1 group)

Final Result

Minimum groups = 2, so transactions = 3-2 = 1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define MAX_PEOPLE 20
#define min(a,b) ((a)<(b)?(a):(b))

int minTransfers(int transactions[][3], int transSize) {
    int balance[MAX_PEOPLE] = {0};
    int maxId = 0;
    
    for (int i = 0; i < transSize; i++) {
        balance[transactions[i][0]] -= transactions[i][2];
        balance[transactions[i][1]] += transactions[i][2];
        if (transactions[i][0] > maxId) maxId = transactions[i][0];
        if (transactions[i][1] > maxId) maxId = transactions[i][1];
    }
    
    int debts[MAX_PEOPLE];
    int n = 0;
    for (int i = 0; i <= maxId; i++) {
        if (balance[i] != 0) {
            debts[n++] = balance[i];
        }
    }
    
    if (n == 0) return 0;
    
    // Find valid subsets
    bool* valid = (bool*)calloc(1 << n, sizeof(bool));
    for (int mask = 0; mask < (1 << n); mask++) {
        int total = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                total += debts[i];
            }
        }
        if (total == 0) {
            valid[mask] = true;
        }
    }
    
    // DP
    int* dp = (int*)malloc((1 << n) * sizeof(int));
    for (int i = 0; i < (1 << n); i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        if (dp[mask] == INT_MAX) continue;
        
        int complement = ((1 << n) - 1) ^ mask;
        for (int subset = complement; subset > 0; subset = (subset - 1) & complement) {
            if (valid[subset]) {
                dp[mask | subset] = min(dp[mask | subset], dp[mask] + 1);
            }
        }
    }
    
    int result = n - dp[(1 << n) - 1];
    free(valid);
    free(dp);
    return result;
}

int main() {
    int transactions[][3] = {{0, 1, 10}, {2, 0, 5}};
    printf("%d\n", minTransfers(transactions, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each subset, we iterate through all its subsets. Total is sum of C(n,k)*2^k = 3^n

✓ Linear Growth

Space Complexity

O(2^n)

DP array of size 2^n to store minimum groups for each bitmask

⚠ Quadratic Space

Constraints

1 ≤ transactions.length ≤ 8
transactions[i].length == 3
0 ≤ from_i, to_i < 12
from_i ≠ to_i
1 ≤ amount_i ≤ 100

23.5K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bitmask Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler