Maximum Number of Accepted Invitations

Maximum Number of Accepted Invitations - Problem

There are m boys and n girls in a class attending an upcoming party. You are given an m x n integer matrix grid, where grid[i][j] equals 0 or 1.

If grid[i][j] == 1, then that means the i-th boy can invite the j-th girl to the party. A boy can invite at most one girl, and a girl can accept at most one invitation from a boy.

Return the maximum possible number of accepted invitations.

Input & Output

Example 1 — Basic Party Invitations

$ Input: grid = [[1,1,1],[1,0,1],[0,0,1]]

› Output: 2

💡 Note: Boy 0 can invite any of the 3 girls. Boy 1 can invite girls 0 or 2. Boy 2 can only invite girl 2. Optimal matching: Boy 0→Girl 1, Boy 1→Girl 0, but Boy 2 can only get Girl 2 which conflicts with Boy 1. So optimal is Boy 0→Girl 0, Boy 1→Girl 2, giving 2 total matches.

Example 2 — Limited Options

$ Input: grid = [[1,0,0,0],[1,0,0,0],[1,1,1,1]]

› Output: 2

💡 Note: Boys 0 and 1 can only invite Girl 0, so only one of them can succeed. Boy 2 can invite any girl (0,1,2,3). Optimal matching: Boy 0→Girl 0, Boy 2→Girl 1, giving 2 total matches.

Example 3 — No Matches Possible

$ Input: grid = [[0]]

› Output: 0

💡 Note: The only boy cannot invite the only girl (grid[0][0] = 0), so no invitations are accepted.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

This is a maximum bipartite matching problem. The key insight is to model boys and girls as two sets in a bipartite graph, where edges represent possible invitations. Use DFS with augmenting paths to find the maximum matching. Best approach: DFS bipartite matching. Time: O(m × n × (m + n)), Space: O(m + n).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each boy, try pairing with each available girl he can invite. Use recursion to explore all possible combinations and track the maximum number of successful pairings.

DFS with Augmenting Paths

⏱️ Time: O(m × n × (m + n)) Space: O(m + n)

Model as bipartite graph matching problem. For each boy, use DFS to find an augmenting path - either to an unmatched girl or through rearranging existing matches to create new opportunities.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible pairing combinations
For each combination, check if all pairs are valid
Track maximum number of valid pairs found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Boy 0

Try pairing him with each available girl

Recursive Exploration

For each pairing, recursively solve for remaining boys

Track Maximum

Keep track of the maximum pairings found

Code -

solution.c — C

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

int backtrack(int boy, int** grid, int m, int n, int* girlTaken) {
    if (boy == m) return 0;
    
    int maxMatches = backtrack(boy + 1, grid, m, n, girlTaken); // Skip this boy
    
    for (int girl = 0; girl < n; girl++) {
        if (grid[boy][girl] == 1 && !girlTaken[girl]) {
            girlTaken[girl] = 1;
            int matches = 1 + backtrack(boy + 1, grid, m, n, girlTaken);
            if (matches > maxMatches) maxMatches = matches;
            girlTaken[girl] = 0;
        }
    }
    
    return maxMatches;
}

int solution(int** grid, int m, int n) {
    int* girlTaken = (int*)calloc(n, sizeof(int));
    int result = backtrack(0, grid, m, n, girlTaken);
    free(girlTaken);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    int** grid = (int**)malloc(10 * sizeof(int*));
    for (int i = 0; i < 10; i++) {
        grid[i] = (int*)malloc(10 * sizeof(int));
    }
    
    // Parse [[1,1,1],[1,0,1],[0,0,1]] format
    int m = 0, n = 0;
    char* ptr = strchr(line, '[');
    ptr++; // Skip first [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[m][n] = *ptr - '0';
                    n++;
                }
                ptr++;
            }
            m++;
        }
        ptr++;
    }
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    for (int i = 0; i < 10; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m×n))

Exponential combinations of all possible boy-girl pairings

✓ Linear Growth

Space Complexity

O(m + n)

Recursion stack depth and arrays to track assignments

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler