Optimal Account Balancing

Optimal Account Balancing - Problem

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

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

A debt is settled when the net balance of each person becomes zero. Multiple transactions between the same people are allowed.

Input & Output

Example 1 — Basic Three Person Settlement

$ 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 balances: Person 0: -$5, Person 1: +$10, Person 2: -$5. Person 1 pays $5 to person 0, and person 1 pays $5 to person 2. Minimum 2 transactions needed.

Example 2 — Already Settled

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

› Output: 1

💡 Note: Net balances: Person 0: -$5, Person 1: +$4, Person 2: $0, Person 0 (unnamed): +$1. After calculating all balances, only 1 transaction needed to settle remaining debts.

Example 3 — No Settlements Needed

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

› Output: 0

💡 Note: This forms a cycle: person 0 → person 1 → person 2 → person 0. All net balances are zero, so no additional transactions needed.

Constraints

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

Visualization

Tap to expand

Asked in

I Intuit 15 U Uber 8 P PayPal 6

The key insight is that only people with non-zero net balances need to participate in settlement transactions. We calculate each person's net balance, then use backtracking to find the minimum number of transactions needed. Best approach uses optimized backtracking with pruning. Time: O(n!), Space: O(n)

Common Approaches

✓ Backtracking with All Permutations

⏱️ Time: O(n!) Space: O(n)

Calculate net balance for each person, then use backtracking to try all possible ways to settle debts. For each person with non-zero balance, try pairing them with every other person.

Optimized Backtracking with Pruning

⏱️ Time: O(n!) Space: O(n)

Same backtracking approach but with optimizations like skipping zero balances early, trying larger amounts first, and pruning when current path exceeds known minimum.

Backtracking with All Permutations — Algorithm Steps

Step 1: Calculate net balance for each person
Step 2: Collect all non-zero balances
Step 3: Use backtracking to try all settlement combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Balances

Determine who owes money and who is owed

Backtrack Pairs

Try pairing creditors with debtors

Find Minimum

Return the minimum transactions needed

Code -

solution.c — C

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

#define MAX_PEOPLE 20
#define MAX_TRANSACTIONS 100

static int balance[MAX_PEOPLE];
static int debts[MAX_PEOPLE];
static int debt_count;

int backtrack(int idx) {
    // Skip zero balances
    while (idx < debt_count && debts[idx] == 0) {
        idx++;
    }
    
    if (idx >= debt_count) {
        return 0;
    }
    
    int min_txns = INT_MAX;
    // Try pairing current person with all others
    for (int i = idx + 1; i < debt_count; i++) {
        if (debts[i] * debts[idx] < 0) {  // Different signs
            debts[i] += debts[idx];  // Settle debt
            int result = 1 + backtrack(idx + 1);
            if (result < min_txns) {
                min_txns = result;
            }
            debts[i] -= debts[idx];  // Backtrack
        }
    }
    
    return min_txns;
}

int solution(int transactions[][3], int num_transactions) {
    // Initialize balance array
    for (int i = 0; i < MAX_PEOPLE; i++) {
        balance[i] = 0;
    }
    
    // Calculate net balance for each person
    for (int i = 0; i < num_transactions; i++) {
        int from_id = transactions[i][0];
        int to_id = transactions[i][1];
        int amount = transactions[i][2];
        balance[from_id] -= amount;
        balance[to_id] += amount;
    }
    
    // Get all non-zero balances
    debt_count = 0;
    for (int i = 0; i < MAX_PEOPLE; i++) {
        if (balance[i] != 0) {
            debts[debt_count++] = balance[i];
        }
    }
    
    if (debt_count == 0) {
        return 0;
    }
    
    return backtrack(0);
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("0\n");
        return 0;
    }
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
        len--;
    }
    
    // Handle empty array
    if (len == 0 || strcmp(line, "[]") == 0) {
        printf("0\n");
        return 0;
    }
    
    static int transactions[MAX_TRANSACTIONS][3];
    int num_transactions = 0;
    
    // Parse 2D array
    char *ptr = line;
    
    // Skip initial '['
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Look for inner '['
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // Skip '['
        
        // Parse three numbers
        char *end;
        transactions[num_transactions][0] = (int)strtol(ptr, &end, 10);
        ptr = end;
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        
        transactions[num_transactions][1] = (int)strtol(ptr, &end, 10);
        ptr = end;
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        
        transactions[num_transactions][2] = (int)strtol(ptr, &end, 10);
        ptr = end;
        
        // Skip to end of inner array
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        num_transactions++;
        
        // Skip comma and space
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    int result = solution(transactions, num_transactions);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Backtracking tries all possible ways to pair people, leading to factorial combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store balances and recursion call stack

⚡ Linearithmic Space

22.0K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler