Maximum Number of Achievable Transfer Requests

Maximum Number of Achievable Transfer Requests - Problem

Imagine a large corporate campus with n buildings numbered from 0 to n-1. It's transfer season, and employees want to move between buildings!

You're given an array of requests where each requests[i] = [from_i, to_i] represents an employee's request to transfer from building from_i to building to_i.

Here's the catch: all buildings are at full capacity. This means a set of transfer requests can only be approved if the net change for each building is zero - the number of employees leaving must equal the number moving in.

Goal: Find the maximum number of transfer requests that can be simultaneously approved while maintaining this balance constraint.

Example: If 2 employees leave building 0 and 1 leaves building 1, then exactly 2 must move to building 0 and 1 must move to building 1 for the transfers to be achievable.

Input & Output

example_1.py — Basic Cycle

$ Input: n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]

› Output: 5

💡 Note: We can approve requests [0,1], [1,0], [0,1], [1,2], [2,0]. Building 0: +1-1+1-1 = 0, Building 1: -1+1-1+1 = 0, Building 2: -1+1 = 0. All buildings balanced.

example_2.py — Simple Swap

$ Input: n = 3, requests = [[0,0],[1,2],[2,1]]

› Output: 3

💡 Note: All three requests can be approved. Building 0: 0, Building 1: -1+1 = 0, Building 2: +1-1 = 0. Perfect balance achieved.

example_3.py — No Valid Combination

$ Input: n = 4, requests = [[0,3],[3,1],[1,2],[2,0]]

› Output: 4

💡 Note: This forms a complete cycle: 0→3→1→2→0. All four requests can be approved simultaneously as they create a balanced cycle.

Constraints

1 ≤ n ≤ 20
1 ≤ requests.length ≤ 16
requests[i].length == 2
0 ≤ from_i, to_i < n
Small input size allows exponential solutions

Visualization

Tap to expand

Understanding the Visualization

Setup

Buildings are at full capacity, employees want to transfer

Constraint

For every employee leaving, someone must take their place

Find the largest set of transfers that maintains balance

Solution

Return the maximum number of achievable requests

Key Takeaway

🎯 Key Insight: This is a constraint satisfaction problem requiring us to find the maximum subset of requests where building capacity changes balance out to zero.

Asked in

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

This is a constraint satisfaction problem where we need to find the maximum subset of transfer requests that maintains building capacity balance. The optimal approach uses backtracking to intelligently explore request combinations, pruning invalid branches early. While the worst-case complexity is still O(2^n), the small input constraints (n ≤ 20, requests ≤ 16) make this approach practical.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsets)	O(2^n × n)	O(n)	Generate all possible subsets of requests and check which ones maintain balance
Backtracking (Optimal)	O(2^n)	O(n)	Use backtracking to explore request combinations while pruning invalid branches early

Brute Force (Try All Subsets) — Algorithm Steps

Generate all possible subsets of requests using bit manipulation
For each subset, simulate the transfers by tracking building changes
Check if all buildings have net change of zero
Keep track of the maximum valid subset size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to generate all 2^n possible subsets of requests

Simulate Transfers

For each subset, track the net change in employee count per building

Check Balance

Verify that all buildings have zero net change (balanced)

Track Maximum

Keep the largest valid subset size found so far

Code -

solution.c — C

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

int maximumRequests(int n, int** requests, int requestsSize, int* requestsColSize) {
    int maxRequests = 0;
    
    // Try all possible subsets using bit manipulation
    for (int mask = 0; mask < (1 << requestsSize); mask++) {
        // Count buildings' net change for this subset
        int* buildingCount = (int*)calloc(n, sizeof(int));
        int requestCount = 0;
        
        for (int i = 0; i < requestsSize; i++) {
            if (mask & (1 << i)) {
                int fromBuilding = requests[i][0];
                int toBuilding = requests[i][1];
                buildingCount[fromBuilding]--;
                buildingCount[toBuilding]++;
                requestCount++;
            }
        }
        
        // Check if all buildings are balanced
        bool isBalanced = true;
        for (int i = 0; i < n; i++) {
            if (buildingCount[i] != 0) {
                isBalanced = false;
                break;
            }
        }
        
        if (isBalanced) {
            maxRequests = (requestCount > maxRequests) ? requestCount : maxRequests;
        }
        
        free(buildingCount);
    }
    
    return maxRequests;
}

int main() {
    int n = 3;
    int requests[][2] = {{0, 1}, {1, 2}, {2, 0}};
    int* requestPtrs[] = {requests[0], requests[1], requests[2]};
    int colSizes[] = {2, 2, 2};
    printf("%d\n", maximumRequests(n, requestPtrs, 3, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsets to check, each taking O(n) time to validate balance

⚠ Quadratic Growth

Space Complexity

O(n)

Array to track building balance changes

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

842 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

Brute Force (Try All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler