1386. Cinema Seat Allocation

class Solution {
    public int maxNumberOfFamilies(int n, int[][] reservedSeats) {
        Map<Integer, Integer> rowMask = new HashMap<>();

        for (int[] rs : reservedSeats) {
            int row = rs[0];
            int seat = rs[1];
            int mask = rowMask.getOrDefault(row, 0);
            mask |= (1 << seat); // bit `seat` set means that seat number is reserved
            rowMask.put(row, mask);
        }

        int leftBlock = (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5);  // seats 2,3,4,5
        int midBlock = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7);   // seats 4,5,6,7
        int rightBlock = (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9); // seats 6,7,8,9

        long total = 0;

        for (int mask : rowMask.values()) {
            if ((mask & leftBlock) == 0 && (mask & rightBlock) == 0) {
                total += 2;
            } else if ((mask & leftBlock) == 0 || (mask & midBlock) == 0 || (mask & rightBlock) == 0) {
                total += 1;
            }
            // else: all three blocks are blocked, this row contributes 0
        }

        long emptyRows = (long) n - rowMask.size();
        total += emptyRows * 2;

        return (int) total;
    }
}

class Solution:
    def maxNumberOfFamilies(self, n, reservedSeats):
        rowMask = {}

        for row, seat in reservedSeats:
            mask = rowMask.get(row, 0)
            mask |= (1 << seat)
            rowMask[row] = mask

        leftBlock = (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5)
        midBlock = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7)
        rightBlock = (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9)

        total = 0

        for mask in rowMask.values():
            if (mask & leftBlock) == 0 and (mask & rightBlock) == 0:
                total += 2
            elif ((mask & leftBlock) == 0 or
                  (mask & midBlock) == 0 or
                  (mask & rightBlock) == 0):
                total += 1

        emptyRows = n - len(rowMask)
        total += emptyRows * 2

        return total

class Solution {
public:
    int maxNumberOfFamilies(int n, vector<vector<int>>& reservedSeats) {
        unordered_map<int, int> rowMask;

        for (auto& rs : reservedSeats) {
            int row = rs[0];
            int seat = rs[1];

            rowMask[row] |= (1 << seat);
        }

        int leftBlock = (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5);
        int midBlock = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7);
        int rightBlock = (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9);

        long long total = 0;

        for (auto& [row, mask] : rowMask) {
            if ((mask & leftBlock) == 0 &&
                (mask & rightBlock) == 0) {
                total += 2;
            }
            else if ((mask & leftBlock) == 0 ||
                     (mask & midBlock) == 0 ||
                     (mask & rightBlock) == 0) {
                total += 1;
            }
        }

        long long emptyRows = (long long)n - rowMask.size();
        total += emptyRows * 2;

        return (int)total;
    }
};

/**
 * @param {number} n
 * @param {number[][]} reservedSeats
 * @return {number}
 */
var maxNumberOfFamilies = function(n, reservedSeats) {
    const rowMask = new Map();

    for (const [row, seat] of reservedSeats) {
        let mask = rowMask.get(row) || 0;
        mask |= (1 << seat);
        rowMask.set(row, mask);
    }

    const leftBlock =
        (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5);

    const midBlock =
        (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7);

    const rightBlock =
        (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9);

    let total = 0;

    for (const mask of rowMask.values()) {
        if ((mask & leftBlock) === 0 &&
            (mask & rightBlock) === 0) {
            total += 2;
        }
        else if ((mask & leftBlock) === 0 ||
                 (mask & midBlock) === 0 ||
                 (mask & rightBlock) === 0) {
            total += 1;
        }
    }

    const emptyRows = n - rowMask.size;
    total += emptyRows * 2;

    return total;
};