A cinema has n rows of seats, numbered from 1 to n and there are ten seats in each row, labelled from 1 to 10 as shown in the figure above.

Given the array reservedSeats containing the numbers of seats already reserved, for example, reservedSeats[i]=[3,8] means the seat located in row 3 and labelled with 8 is already reserved. 

Return the maximum number of four-person families you can allocate on the cinema seats. A four-person family occupies fours seats in one row, that are next to each other. Seats across an aisle (such as [3,3] and [3,4]) are not considered to be next to each other, however, It is permissible for the four-person family to be separated by an aisle, but in that case, exactly two people have to sit on each side of the aisle.

Example 1:

Input: n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
Output: 4
Explanation: The figure above shows the optimal allocation for four families, where seats mark with blue are already reserved and contiguous seats mark with orange are for one family. 

Example 2:

Input: n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
Output: 2

Example 3:

Input: n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
Output: 4

Constraints:

• 1 <= n <= 10^9
• 1 <= reservedSeats.length <= min(10*n, 10^4)
• reservedSeats[i].length == 2
• 1 <= reservedSeats[i][0] <= n
• 1 <= reservedSeats[i][1] <= 10
• All reservedSeats[i] are distinct.

Solution: HashTable + Greedy

if both seat[2~5] seat[6~9] are empty, seat two groups.
if any of seat[2~5] seat[4~7] seat[6~9] is empty seat one group.
if there is no one sit in a row, seat two groups.

Time complexity: O(|reservedSeats|)
Space complexity: O(|rows|)

// Author: Huahua
class Solution {
public:
  int maxNumberOfFamilies(int n, vector<vector<int>>& reservedSeats) {
    unordered_map<int, int> rows;
    for (auto& seat : reservedSeats)
      rows[seat[0]] |= 1 << (seat[1] - 1);
    
    int ans = (n - rows.size()) * 2;
    
    for (const auto& [idx, row] : rows) {
      int s2 = row & 0b0000011110;
      int s4 = row & 0b0001111000;
      int s6 = row & 0b0111100000;
      if (s2 == 0 && s6 == 0)
        ans += 2;
      else if (s2 == 0 || s4 == 0 || s6 == 0)
        ans += 1;
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 1386. Cinema Seat Allocation appeared first on Huahua's Tech Road.

Given a m * n matrix seats  that represent seats distributions in a classroom. If a seat is broken, it is denoted by '#' character otherwise it is denoted by a '.' character.

Students can see the answers of those sitting next to the left, right, upper left and upper right, but he cannot see the answers of the student sitting directly in front or behind him. Return the maximum number of students that can take the exam together without any cheating being possible..

Students must be placed in seats in good condition.

Example 1:

Input: seats = [["#",".","#","#",".","#"],
                [".","#","#","#","#","."],
                ["#",".","#","#",".","#"]]
Output: 4
Explanation: Teacher can place 4 students in available seats so they don't cheat on the exam. 

Example 2:

Input: seats = [[".","#"],
                ["#","#"],
                ["#","."],
                ["#","#"],
                [".","#"]]
Output: 3
Explanation: Place all students in available seats. 

Example 3:

Input: seats = [["#",".",".",".","#"],
                [".","#",".","#","."],
                [".",".","#",".","."],
                [".","#",".","#","."],
                ["#",".",".",".","#"]]
Output: 10
Explanation: Place students in available seats in column 1, 3 and 5.

Constraints:

• seats contains only characters '.' and'#'.
• m == seats.length
• n == seats[i].length
• 1 <= m <= 8
• 1 <= n <= 8

Solution 1: DFS (TLE)

Time complexity: O(2^(m*n)) = O(2^64)
Space complexity: O(m*n)

Solution 2: DP

Since how to fill row[i+1] only depends on row[i]’s state, we can define

dp[i][s] as the max # of students after filling i rows and s (as a binary string) is the states i-th row.

dp[i+1][t] = max{dp[i][s] + bits(t)} if row[i] = s && row[i +1] = t is a valid state.

Time complexity: O(m*2^(n+n)*n) = O(2^22)
Space complexity: O(m*2^n) = O(2^11) -> O(2^n)

// Author: Huahua
class Solution {
public:
  int maxStudents(vector<vector<char>>& seats) {
    int m = seats.size();
    int n = seats[0].size();
    vector<vector<int>> dp(m + 1, vector<int>(1 << n));    
    for (int i = 0; i < m; ++i)
      for (int l = 0; l < (1 << n); ++l)
        for (int c = 0; c < (1 << n); ++c) {
          bool flag = true;
          for (int j = 0; j < n && flag; ++j) {
            if (!(c & (1 << j))) continue;
            if (seats[i][j] == '#') flag = false;            
            bool l = j == 0 ? false : (c & (1 << (j - 1)));
            bool r = j == n - 1 ? false : (c & (1 << (j + 1)));
            bool ul = (j == 0 || i == 0) ? false : (l & (1 << (j - 1)));
            bool ur = (j == n - 1 || i == 0) ? false : (l & (1 << (j + 1)));
            if (l || r || ul || ur) flag = false;
          }
          if (flag)
            dp[i + 1][c] = max(dp[i + 1][c], dp[i][l] + __builtin_popcount(c));
        }
    return *max_element(begin(dp[m]), end(dp[m]));
  }
};

// Author: Huahua
class Solution {
public:
  int maxStudents(vector<vector<char>>& seats) {
    const int m = seats.size();
    const int n = seats[0].size();
    vector<int> s(m + 1);    
    for (int i = 1; i <= m; ++i)
      for (int j = 0; j < n; ++j)
        s[i] |= (seats[i - 1][j] == '.') << j;
    
    vector<vector<int>> dp(m + 1, vector<int>(1 << n));        
    for (int i = 1; i <= m; ++i)      
      for (int c = s[i];;c = (c - 1) & s[i]) {
        if (c & (c >> 1)) continue;
        for (int l = s[i - 1];;l = (l - 1) & s[i - 1]) {
          if (!(l & (c >> 1)) && !((l >> 1) & c))
            dp[i][c] = max(dp[i][c], dp[i - 1][l] + __builtin_popcount(c));          
          if (l == 0) break;
        }
        if (c == 0) break;
      }
    return *max_element(begin(dp[m]), end(dp[m]));
  }
};

The post 花花酱 LeetCode 1349. Maximum Students Taking Exam appeared first on Huahua's Tech Road.