Maximum Students Taking Exam - Practice Coding Problems

Maximum Students Taking Exam - Problem

Imagine you're a proctor overseeing an exam in a classroom with m × n seats arranged in a grid. Some seats are broken (marked with '#') while functional seats are marked with '.'.

Here's the challenge: students can cheat by looking at answers from their neighbors! Specifically, a student can see the answers of those sitting:

Directly to their left
Directly to their right
To their upper left diagonal
To their upper right diagonal

However, students cannot see answers from those sitting directly in front or behind them.

Your goal is to find the maximum number of students that can take the exam simultaneously without any possibility of cheating. Students can only be placed in functional seats (marked with '.').

Example: In a classroom where students are seated like chess pieces, you need to ensure no student can peek at their neighbor's paper!

Input & Output

example_1.py — Basic Classroom

$ Input: seats = [["#",".","#","#",".","#"],[".","#","#","#","#","."],["#",".","#","#",".","#"]]

› Output: 4

💡 Note: The optimal arrangement places students at positions (0,1), (0,4), (1,0), and (1,5). No student can see another student's answers due to the seating pattern and broken seats blocking some sight lines.

example_2.py — All Broken Seats

$ Input: seats = [["#","#"],["#","#"],["#","#"]]

› Output: 0

💡 Note: All seats are broken, so no students can take the exam. The maximum number of students is 0.

example_3.py — Single Row

$ Input: seats = [[".","#",".",".","#","."]]

› Output: 3

💡 Note: In a single row, we can place students at positions (0,0), (0,2), and (0,5). Position (0,3) cannot be used because it would be adjacent to the student at (0,2).

Visualization

Tap to expand

Understanding the Visualization

Identify Safe Zones

Mark all functional seats and identify potential cheating sight lines

Row-by-Row Placement

For each row, determine all valid student arrangements (no adjacent seats)

Check Diagonal Conflicts

Ensure no student in current row can see diagonally to previous row

Optimize Transitions

Use dynamic programming to find the maximum valid placement across all rows

Key Takeaway

🎯 Key Insight: This is a constrained optimization problem where we use bitmask DP to efficiently explore all valid seating arrangements row by row, ensuring no cheating is possible through strategic placement.

Time & Space Complexity

Time Complexity

⏱️

O(m × 4^n × 2^n)

m rows, up to 4^n transitions between valid masks, 2^n possible masks per row

⚠ Quadratic Growth

Space Complexity

O(m × 2^n)

DP table stores maximum students for each row and valid mask combination

⚠ Quadratic Space

Constraints

m == seats.length
n == seats[i].length
1 ≤ m ≤ 8
1 ≤ n ≤ 8
seats[i][j] is either '.' or '#'

Asked in

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

The optimal solution uses bitmask dynamic programming to represent valid seating arrangements for each row. The key insight is that we only need to check conflicts between adjacent rows, making this a row-by-row optimization problem with O(m × 4^n × 2^n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Bitmask Dynamic Programming	O(m × 4^n × 2^n)	O(m × 2^n)	Use bitmask DP to represent valid row states and build solution row by row
Brute Force (Try All Combinations)	O(2^(m×n) × m×n)	O(m×n)	Try every possible seating arrangement and pick the maximum valid one

Bitmask Dynamic Programming — Algorithm Steps

For each row, generate all valid bitmasks (no adjacent students)
Create DP array where dp[i][mask] = max students in first i rows ending with mask
For each transition, check if current row conflicts with previous row
Return maximum value from the last row

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Valid Masks

For each row, find all valid seating patterns (no adjacent students, no broken seats)

Initialize First Row

Set DP values for first row based on number of students in each valid mask

Transition Between Rows

For each valid mask in current row, check compatibility with previous row masks

Update DP Values

Update DP[current_mask] = max(DP[prev_mask] + students_in_current_mask)

Code -

solution.c — C

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

int countBits(int mask) {
    int count = 0;
    while (mask) {
        count += mask & 1;
        mask >>= 1;
    }
    return count;
}

bool isCompatible(int currMask, int prevMask, int n) {
    for (int j = 0; j < n; j++) {
        if (currMask & (1 << j)) {
            if (j > 0 && (prevMask & (1 << (j-1)))) return false;
            if (j < n-1 && (prevMask & (1 << (j+1)))) return false;
        }
    }
    return true;
}

int* getValidMasks(char** seats, int row, int n, int* count) {
    int* valid = malloc((1 << n) * sizeof(int));
    *count = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        bool validMask = true;
        for (int j = 0; j < n; j++) {
            if (mask & (1 << j)) {
                if (seats[row][j] == '#') {
                    validMask = false;
                    break;
                }
                if (j > 0 && (mask & (1 << (j-1)))) {
                    validMask = false;
                    break;
                }
            }
        }
        if (validMask) {
            valid[(*count)++] = mask;
        }
    }
    
    return valid;
}

int maxStudents(char** seats, int seatsSize, int* seatsColSize) {
    int m = seatsSize, n = seatsColSize[0];
    
    // Get valid masks for each row
    int** validMasks = malloc(m * sizeof(int*));
    int* validCounts = malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        validMasks[i] = getValidMasks(seats, i, n, &validCounts[i]);
    }
    
    // DP with hash map simulation using arrays
    int maxMasks = 1 << n;
    int* prevDp = calloc(maxMasks, sizeof(int));
    bool* prevUsed = calloc(maxMasks, sizeof(bool));
    
    // Initialize first row
    for (int i = 0; i < validCounts[0]; i++) {
        int mask = validMasks[0][i];
        prevDp[mask] = countBits(mask);
        prevUsed[mask] = true;
    }
    
    // Process remaining rows
    for (int row = 1; row < m; row++) {
        int* currDp = calloc(maxMasks, sizeof(int));
        bool* currUsed = calloc(maxMasks, sizeof(bool));
        
        for (int i = 0; i < validCounts[row]; i++) {
            int currMask = validMasks[row][i];
            currUsed[currMask] = true;
            
            for (int prevMask = 0; prevMask < maxMasks; prevMask++) {
                if (prevUsed[prevMask] && isCompatible(currMask, prevMask, n)) {
                    int newCount = prevDp[prevMask] + countBits(currMask);
                    if (newCount > currDp[currMask]) {
                        currDp[currMask] = newCount;
                    }
                }
            }
        }
        
        free(prevDp);
        free(prevUsed);
        prevDp = currDp;
        prevUsed = currUsed;
    }
    
    // Find maximum
    int result = 0;
    for (int mask = 0; mask < maxMasks; mask++) {
        if (prevUsed[mask] && prevDp[mask] > result) {
            result = prevDp[mask];
        }
    }
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(validMasks[i]);
    }
    free(validMasks);
    free(validCounts);
    free(prevDp);
    free(prevUsed);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × 4^n × 2^n)

m rows, up to 4^n transitions between valid masks, 2^n possible masks per row

⚠ Quadratic Growth

Space Complexity

O(m × 2^n)

DP table stores maximum students for each row and valid mask combination

⚠ Quadratic Space

Constraints

m == seats.length
n == seats[i].length
1 ≤ m ≤ 8
1 ≤ n ≤ 8
seats[i][j] is either '.' or '#'

34.4K Views

Medium-High Frequency

~25 min Avg. Time

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

Bitmask Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler