Maximum Number of Accepted Invitations - Practice Coding Problems

Maximum Number of Accepted Invitations - Problem

Party Invitation Matching Problem

Imagine you're organizing a school party where m boys want to invite n girls as their dance partners. You have an m × n binary matrix grid where:

• grid[i][j] = 1 means the i-th boy can invite the j-th girl
• grid[i][j] = 0 means they're incompatible

Rules:
🎯 Each boy can invite at most one girl
🎯 Each girl can accept at most one invitation

Your goal is to find the maximum number of successful boy-girl pairs that can be formed for the party. This is a classic bipartite matching problem where we need to optimally pair elements from two distinct sets.

Input & Output

example_1.py — Basic matching

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

› Output: 3

💡 Note: Boy 0 can invite Girl 0, Boy 1 can invite Girl 1, and Boy 2 can invite Girl 2. All three invitations can be accepted simultaneously, resulting in 3 successful pairs.

example_2.py — Limited compatibility

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

› Output: 1

💡 Note: Only Girl 0 is compatible with both Boy 0 and Boy 1, but she can accept only one invitation. Boy 2 has no compatible girls. Maximum matches = 1.

example_3.py — Perfect matching

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

› Output: 2

💡 Note: Both boys are compatible with both girls. We can form pairs (Boy 0, Girl 0) and (Boy 1, Girl 1), or (Boy 0, Girl 1) and (Boy 1, Girl 0). Either way, maximum matches = 2.

Visualization

Tap to expand

Understanding the Visualization

Build Compatibility Graph

Create a bipartite graph where edges represent possible boy-girl pairs

Apply Matching Algorithm

Use DFS to find augmenting paths that maximize total matches

Handle Conflicts

When a girl is already matched, try to reassign her current partner

Count Maximum Pairs

Return the total number of successful boy-girl pairs formed

Key Takeaway

🎯 Key Insight: The optimal solution uses DFS to find augmenting paths in the bipartite graph, allowing reassignment of existing matches to accommodate new ones, thus maximizing the total number of successful pairings.

Time & Space Complexity

Time Complexity

⏱️

O(m × n × (m + n))

For each boy, we may need to explore all edges in worst case

✓ Linear Growth

Space Complexity

O(n + m)

Space for match arrays and visited tracking during DFS

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is either 0 or 1
Each boy can invite at most one girl
Each girl can accept at most one invitation

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

This is a classic bipartite matching problem solved optimally using DFS with augmenting paths. The key insight is that when a desired girl is already matched, we can try to find an alternative match for her current partner, potentially creating a chain of reassignments that maximizes total matches. Time complexity: O(m × n × (m + n)).

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Augmenting Paths (Optimal)	O(m × n × (m + n))	O(n + m)	Use DFS to find augmenting paths in the bipartite graph for maximum matching

DFS with Augmenting Paths (Optimal) — Algorithm Steps

For each boy, try to find a matching using DFS
If a girl is available, match them directly
If a girl is already matched, try to find an alternative match for her current partner
Use visited array to avoid infinite loops during DFS
Count successful matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Try matching Boy 0

DFS tries to find a girl for Boy 0

Girl already matched

If target girl is taken, try to reassign her current partner

Find alternative path

Recursively find new match for displaced boy

Update matching

Update matches along the augmenting path

Code -

solution.c — C

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

bool dfs(int boy, bool* visited, int** grid, int* match, int n) {
    for (int girl = 0; girl < n; girl++) {
        if (grid[boy][girl] == 1 && !visited[girl]) {
            visited[girl] = true;
            
            // If girl is free or we can find alternative match for her current partner
            if (match[girl] == -1 || dfs(match[girl], visited, grid, match, n)) {
                match[girl] = boy;
                return true;
            }
        }
    }
    return false;
}

int maximumInvitations(int** grid, int m, int n) {
    int* match = (int*)malloc(n * sizeof(int)); // match[i] = which boy is matched with girl i
    for (int i = 0; i < n; i++) {
        match[i] = -1;
    }
    
    int result = 0;
    for (int boy = 0; boy < m; boy++) {
        bool* visited = (bool*)calloc(n, sizeof(bool));
        if (dfs(boy, visited, grid, match, n)) {
            result++;
        }
        free(visited);
    }
    
    free(match);
    return result;
}

int main() {
    int rows = 3, cols = 3;
    int** grid = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        grid[i] = (int*)malloc(cols * sizeof(int));
    }
    
    int data[3][3] = {{1,1,1},{1,0,1},{0,0,1}};
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            grid[i][j] = data[i][j];
        }
    }
    
    printf("%d\n", maximumInvitations(grid, rows, cols));
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × (m + n))

For each boy, we may need to explore all edges in worst case

✓ Linear Growth

Space Complexity

O(n + m)

Space for match arrays and visited tracking during DFS

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is either 0 or 1
Each boy can invite at most one girl
Each girl can accept at most one invitation

42.0K Views

Medium-High Frequency

~25 min Avg. Time

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

DFS with Augmenting Paths (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler