Maximum Compatibility Score Sum

Maximum Compatibility Score Sum - Problem

There is a survey that consists of n questions where each question's answer is either 0 (no) or 1 (yes).

The survey was given to m students numbered from 0 to m - 1 and m mentors numbered from 0 to m - 1. The answers of the students are represented by a 2D integer array students where students[i] is an integer array that contains the answers of the i-th student. The answers of the mentors are represented by a 2D integer array mentors where mentors[j] is an integer array that contains the answers of the j-th mentor.

Each student will be assigned to one mentor, and each mentor will have one student assigned to them. The compatibility score of a student-mentor pair is the number of answers that are the same for both the student and the mentor.

For example, if the student's answers were [1, 0, 1] and the mentor's answers were [0, 0, 1], then their compatibility score is 2 because only the second and the third answers are the same.

You are tasked with finding the optimal student-mentor pairings to maximize the sum of the compatibility scores.

Given students and mentors, return the maximum compatibility score sum that can be achieved.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Student 0 with Mentor 1: [1,1,0] vs [0,1,1] → 1 match (position 1). Student 1 with Mentor 0: [1,0,1] vs [1,0,1] → 3 matches (all positions). Total: 1 + 3 = 4.

Example 2 — Different Assignment Better

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

› Output: 0

💡 Note: All students answer [0,0]. Best pairing gives 0 compatibility since no mentor matches any student perfectly. Any assignment results in score 0.

Example 3 — Perfect Matches

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

› Output: 6

💡 Note: Perfect matching: Student 0 with Mentor 0 gives 3 matches, Student 1 with Mentor 1 gives 3 matches. Total: 3 + 3 = 6.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

This is an assignment optimization problem where we need to find the best one-to-one pairing between students and mentors. The key insight is that with small constraints (m ≤ 8), we can use dynamic programming with bitmasks to efficiently explore all possible assignments while avoiding redundant calculations. Time: O(2ᵐ × m × n), Space: O(2ᵐ × m).

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force with Backtracking

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

Generate all permutations of mentor assignments for students and calculate the total compatibility score for each, keeping track of the maximum.

Dynamic Programming with Bitmask

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

Optimize backtracking by using a bitmask to represent which mentors are used and memoize results for each state to avoid redundant calculations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int target) {
    int* dp = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        dp[i] = -1;
    }
    dp[numsSize - 1] = 0;
    
    for (int i = numsSize - 2; i >= 0; i--) {
        for (int j = i + 1; j < numsSize; j++) {
            if (abs(nums[j] - nums[i]) <= target && dp[j] != -1) {
                dp[i] = (dp[i] > 1 + dp[j]) ? dp[i] : 1 + dp[j];
            }
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - handle empty array case
    int nums[1000];
    int numsSize = 0;
    
    // Skip opening bracket
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']') break;
        
        // Parse number (handle negative numbers)
        int num = 0;
        int sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        while (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            ptr++;
        }
        nums[numsSize++] = sign * num;
    }
    
    int target;
    scanf("%d", &target);
    
    int result = solution(nums, numsSize, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

845 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