README.md

1386. 安排电影院座位

English Version

题目描述

如上图所示，电影院的观影厅中有 n 行座位，行编号从 1 到 n ，且每一行内总共有 10 个座位，列编号从 1 到 10 。

给你数组 reservedSeats ，包含所有已经被预约了的座位。比如说，researvedSeats[i]=[3,8] ，它表示第 3 行第 8 个座位被预约了。

请你返回 最多能安排多少个 4 人家庭 。4 人家庭要占据 同一行内连续 的 4 个座位。隔着过道的座位（比方说 [3,3] 和 [3,4]）不是连续的座位，但是如果你可以将 4 人家庭拆成过道两边各坐 2 人，这样子是允许的。

 

示例 1：

输入：n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
输出：4
解释：上图所示是最优的安排方案，总共可以安排 4 个家庭。蓝色的叉表示被预约的座位，橙色的连续座位表示一个 4 人家庭。

示例 2：

输入：n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
输出：2

示例 3：

输入：n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
输出：4

 

提示：

• 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
• 所有 reservedSeats[i] 都是互不相同的。

解法

方法一：哈希表 + 位运算

用哈希表 m 记录每一行的座位预定情况。

哈希表中没有出现的行，每行可坐 2 个 4 人家庭，即 (n - len(m)) << 1。

遍历哈希表中出现的行，依次贪心尝试 1234, 5678, 3456 这几个连续座位（注意这里下标从 0 开始）是否均没被预定，是则累加答案，并且将此连续座位置为已预定。

Python3

class Solution:
    def maxNumberOfFamilies(self, n: int, reservedSeats: List[List[int]]) -> int:
        m = defaultdict(int)
        for i, j in reservedSeats:
            m[i] = m[i] | (1 << (10 - j))
        masks = (0b0111100000, 0b0000011110, 0b0001111000)
        ans = (n - len(m)) << 1
        for v in m.values():
            for mask in masks:
                if (v & mask) == 0:
                    v |= mask
                    ans += 1
        return ans

Java

class Solution {
    public int maxNumberOfFamilies(int n, int[][] reservedSeats) {
        Map<Integer, Integer> m = new HashMap<>();
        for (int[] e : reservedSeats) {
            int i = e[0], j = 10 - e[1];
            int v = m.getOrDefault(i, 0);
            v |= 1 << j;
            m.put(i, v);
        }
        int[] masks = {0b0111100000, 0b0000011110, 0b0001111000};
        int ans = (n - m.size()) << 1;
        for (int v : m.values()) {
            for (int mask : masks) {
                if ((v & mask) == 0) {
                    v |= mask;
                    ++ans;
                }
            }
        }
        return ans;
    }
}

C++

class Solution {
public:
    int maxNumberOfFamilies(int n, vector<vector<int>>& reservedSeats) {
        unordered_map<int, int> m;
        for (auto& e : reservedSeats) {
            int i = e[0], j = 10 - e[1];
            m[i] |= (1 << j);
        }
        vector<int> masks = {0b0111100000, 0b0000011110, 0b0001111000};
        int ans = (n - m.size()) << 1;
        for (auto& [_, v] : m) {
            for (int& mask : masks) {
                if ((v & mask) == 0) {
                    v |= mask;
                    ++ans;
                }
            }
        }
        return ans;
    }
};

Go

func maxNumberOfFamilies(n int, reservedSeats [][]int) int {
	m := map[int]int{}
	for _, e := range reservedSeats {
		i, j := e[0], 10-e[1]
		m[i] |= 1 << j
	}
	masks := []int{0b0111100000, 0b0000011110, 0b0001111000}
	ans := (n - len(m)) << 1
	for _, v := range m {
		for _, mask := range masks {
			if (v & mask) == 0 {
				v |= mask
				ans++
			}
		}
	}
	return ans
}

...