Maximum Number of Achievable Transfer Requests - Problem

We have n buildings numbered from 0 to n - 1. Each building has a number of employees. It's transfer season, and some employees want to change the building they reside in.

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

All buildings are full, so a list of requests is achievable only if for each building, the net change in employee transfers is zero. This means the number of employees leaving is equal to the number of employees moving in.

Return the maximum number of achievable transfer requests.

Input & Output

Example 1 — Balanced Transfers

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

› Output: 5

💡 Note: We can accept requests [0,1],[1,0],[0,1],[1,2],[2,0]. Net changes: building 0: -1+1-1+1=1-1=0, building 1: +1-1+1-1=0, building 2: +1-1=0, buildings 3,4 unchanged=0. All buildings balanced.

Example 2 — Simple Case

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

› Output: 3

💡 Note: All requests can be accepted: [0,0] is self-transfer (no net change), [1,2] and [2,1] cancel each other out. Net changes all zero.

Example 3 — No Valid Subset

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

› Output: 2

💡 Note: Both requests can be accepted since they involve different pairs of buildings. Building 0: -1, building 1: +1, building 2: -1, building 3: +1. All balanced.

Constraints

1 ≤ n ≤ 20
1 ≤ requests.length ≤ 16
requests[i].length == 2
0 ≤ from_i, to_i < n

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that valid transfers require zero net change for each building. Best approach is backtracking with pruning to efficiently explore all possible request subsets. Time: O(2^m), Space: O(n + m)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(2^m) Space: O(n + m)

Recursively try including or excluding each request, maintaining a balance array. Prune branches early when they can't lead to better solutions.

Brute Force - Try All Subsets

⏱️ Time: O(2^m × n) Space: O(n)

For each possible subset of requests, check if the net transfer for each building is zero. Keep track of the maximum size valid subset found.

Backtracking with Pruning — Algorithm Steps

Start with empty request set and zero balance
For each request, try including it (update balance) or excluding it
If balance becomes invalid, backtrack immediately
Track maximum valid subset size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Point

For each request, decide to include or exclude

Update Balance

Track net changes for each building

Backtrack

Undo changes and try alternative path

Code -

solution.c — C

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

int maxRequests = 0;

void backtrack(int index, int requests[][2], int m, int balance[], int n, int count) {
    // Base case: processed all requests
    if (index == m) {
        int valid = 1;
        for (int i = 0; i < n; i++) {
            if (balance[i] != 0) {
                valid = 0;
                break;
            }
        }
        if (valid && count > maxRequests) {
            maxRequests = count;
        }
        return;
    }
    
    // Pruning: if remaining requests can't improve answer
    if (count + (m - index) <= maxRequests) {
        return;
    }
    
    // Try excluding current request
    backtrack(index + 1, requests, m, balance, n, count);
    
    // Try including current request
    int fromBuilding = requests[index][0];
    int toBuilding = requests[index][1];
    balance[fromBuilding]--;
    balance[toBuilding]++;
    
    backtrack(index + 1, requests, m, balance, n, count + 1);
    
    // Backtrack
    balance[fromBuilding]++;
    balance[toBuilding]--;
}

int solution(int n, int requests[][2], int m) {
    maxRequests = 0;
    int balance[20] = {0}; // Assuming n <= 20
    backtrack(0, requests, m, balance, n, 0);
    return maxRequests;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    scanf(" %[^\n]", line);
    
    // Parse 2D array manually
    int requests[16][2]; // Assuming max 16 requests
    int m = 0;
    
    char *ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            requests[m][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            requests[m][1] = atoi(ptr);
            while (*ptr != ']') ptr++;
            ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(n, requests, m);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

In worst case, still explores all subsets, but pruning helps in practice

✓ Linear Growth

Space Complexity

O(n + m)

Balance array O(n) plus recursion stack O(m)

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Maximum Number of Achievable Transfer Requests - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler