Codestin Search App

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.

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

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.

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
✓ Backtracking with Recursion	O(m!)	O(m)	Try all possible student-mentor assignments using recursive backtracking
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 — Algorithm Steps

Calculate compatibility scores between all student-mentor pairs
Use backtracking to try assigning each student to each available mentor
For each complete assignment, calculate the total compatibility sum
Track and return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Compatibility

Compute scores between all student-mentor pairs

Try Assignments

For each student, try pairing with each available mentor

Backtrack

If assignment leads to suboptimal result, backtrack and try next option

Find Maximum

Return the assignment with highest total compatibility

Code -

solution.c — C

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

int compatibility[8][8];
int m;

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

int backtrack(int studentIdx, int* usedMentors) {
    if (studentIdx == m) return 0;
    
    int maxScore = 0;
    for (int mentorIdx = 0; mentorIdx < m; mentorIdx++) {
        if (!usedMentors[mentorIdx]) {
            usedMentors[mentorIdx] = 1;
            int score = compatibility[studentIdx][mentorIdx] + backtrack(studentIdx + 1, usedMentors);
            maxScore = max(maxScore, score);
            usedMentors[mentorIdx] = 0;
        }
    }
    return maxScore;
}

int maxCompatibilitySum(int students[][8], int mentors[][8], int rows, int cols) {
    m = rows;
    
    // 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;
        }
    }
    
    int usedMentors[8] = {0};
    return backtrack(0, usedMentors);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m!)

We try all m! possible assignments of students to mentors

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth is at most m levels deep

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler