Maximum Compatibility Score Sum - Practice Coding Problems

Maximum Compatibility Score Sum - Problem

Maximum Compatibility Score Sum

Imagine you're running a mentorship program where you need to pair students with mentors based on their survey responses! 🎓

You have m students and m mentors who each completed a survey with n binary questions (answered with 0 or 1). Your goal is to create perfect one-to-one pairings that maximize the total compatibility.

The compatibility score between a student and mentor is simply the number of questions they answered the same way. For example:
• Student answers: [1, 0, 1]
• Mentor answers: [0, 0, 1]
• Compatibility score: 2 (positions 1 and 2 match)

Since each student must be paired with exactly one mentor (and vice versa), you need to find the optimal assignment that maximizes the sum of all compatibility scores.

Input & Output

example_1.py — Basic Case

$ Input: students = [[1,1,0],[1,0,1],[0,0,1]], mentors = [[1,0,0],[0,0,1],[1,1,0]]

› Output: 8

💡 Note: Optimal pairing: Student 0 ↔ Mentor 2 (score 2), Student 1 ↔ Mentor 0 (score 2), Student 2 ↔ Mentor 1 (score 4). Total: 2+2+4 = 8

example_2.py — Perfect Match

$ Input: students = [[0,0],[0,0],[0,0]], mentors = [[1,1],[0,1],[1,0]]

› Output: 0

💡 Note: All students answered [0,0] but no mentor has the same answers. Best we can do is 0 matches per pair, total = 0.

example_3.py — Single Pair

$ Input: students = [[1,0,1]], mentors = [[0,1,1]]

› Output: 1

💡 Note: Only one student and one mentor. They match on position 2, so compatibility score = 1.

Visualization

Tap to expand

Understanding the Visualization

Build Compatibility Matrix

Calculate how many survey answers match between each student-mentor pair

Generate All Assignments

Use bitmask to represent which mentors are taken and try all possibilities

Memoize Subproblems

Cache results for each state to avoid recalculating same scenarios

Return Maximum

Find the assignment that gives the highest total compatibility score

Key Takeaway

🎯 Key Insight: This assignment problem can be solved optimally using bitmask dynamic programming in O(m² × 2^m) time, which is much more efficient than trying all m! permutations. The bitmask elegantly tracks which mentors are available while memoization prevents redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(m² × 2^m)

For each of 2^m possible mentor assignments, we try m mentors for m students

✓ Linear Growth

Space Complexity

O(m × 2^m)

Memoization table stores results for each (student, mentor_mask) pair

✓ Linear Space

Constraints

m == students.length == mentors.length
n == students[i].length == mentors[j].length
1 ≤ m, n ≤ 8
students[i][k] is either 0 or 1
mentors[j][k] is either 0 or 1

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

This problem requires finding the optimal assignment of students to mentors to maximize compatibility scores. The key insight is that this is a perfect matching problem with a small constraint (m ≤ 8), making bitmask dynamic programming the optimal approach. We precompute compatibility scores, then use DP with memoization to explore all 2^m possible mentor assignments in O(m² × 2^m) time, which is much better than the O(m!) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(m² × 2^m)	O(m × 2^m)	Use bitmask DP to efficiently track used mentors and memoize subproblems
Backtracking with Recursion	O(m!)	O(m)	Try all possible student-mentor assignments using recursive backtracking

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Precompute compatibility scores between all student-mentor pairs
Use bitmask to represent which mentors are already assigned
For each state (student index, mentor mask), try assigning current student to each available mentor
Memoize results to avoid recomputing same subproblems
Return maximum score for initial state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize State

Start with student 0 and empty mentor mask (000)

Try Assignments

For each available mentor, set corresponding bit in mask

Memoize Results

Cache results for each (student_index, mentor_mask) pair

Optimal Substructure

Use cached results when same state is encountered again

Code -

solution.c — C

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

#define MAX_M 8
int compatibility[MAX_M][MAX_M];
int memo[MAX_M][1 << MAX_M];
int m;

int max(int a, int b) {
    return a > b ? a : b;
}

int dp(int studentIdx, int mentorMask) {
    if (studentIdx == m) return 0;
    
    if (memo[studentIdx][mentorMask] != -1) {
        return memo[studentIdx][mentorMask];
    }
    
    int maxScore = 0;
    for (int mentorIdx = 0; mentorIdx < m; mentorIdx++) {
        if (!(mentorMask & (1 << mentorIdx))) {  // mentor not used
            int newMask = mentorMask | (1 << mentorIdx);
            int score = compatibility[studentIdx][mentorIdx] + dp(studentIdx + 1, newMask);
            maxScore = max(maxScore, score);
        }
    }
    
    memo[studentIdx][mentorMask] = maxScore;
    return maxScore;
}

int maxCompatibilitySum(int students[][MAX_M], int mentors[][MAX_M], int rows, int cols) {
    m = rows;
    
    // Initialize memo with -1
    memset(memo, -1, sizeof(memo));
    
    // Precompute compatibility scores
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            int score = 0;
            for (int k = 0; k < cols; k++) {
                if (students[i][k] == mentors[j][k]) score++;
            }
            compatibility[i][j] = score;
        }
    }
    
    return dp(0, 0);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × 2^m)

For each of 2^m possible mentor assignments, we try m mentors for m students

✓ Linear Growth

Space Complexity

O(m × 2^m)

Memoization table stores results for each (student, mentor_mask) pair

✓ Linear Space

Constraints

m == students.length == mentors.length
n == students[i].length == mentors[j].length
1 ≤ m, n ≤ 8
students[i][k] is either 0 or 1
mentors[j][k] is either 0 or 1

32.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler