跳转至

1386. 安排电影院座位

题目描述

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

给定一个二维数组 reservedSeats ，其中 reservedSeats[i] = [rowi, seati] 表示第 rowi 行的座位 seati 已经被预定。

四人小组必须被安排在同一排的四个座位上。该小组可以坐在以下座位块之一：

  • 座位 2, 3, 4, 5
  • 座位 4, 5, 6, 7
  • 座位 6, 7, 8, 9

只有当该块中的所有座位都 没有 被预订时，才能使用该块。每个座位 最多 只能分配给一个小组。

返回一个整数，表示可以分配的 最大 四人小组数量。

 

示例 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 <= 109
  • 1 <= reservedSeats.length <= min(10 * n, 104)
  • reservedSeats[i] == [rowi, seati]
  • 1 <= rowi <= n
  • 1 <= seati <= 10
  • 所有 reservedSeats[i] 都是互不相同的。

解法

方法一：哈希表 + 状态压缩

我们用哈希表 \(d\) 来存储所有已经被预约的座位，其中键为行号，值为该行上已经被预约的座位的状态，即一个二进制数，第 \(j\) 位为 \(1\) 表示第 \(j\) 个座位已经被预约，为 \(0\) 表示第 \(j\) 个座位尚未被预约。

我们遍历 \(reservedSeats\)，对于每个座位 \((i, j)\)，将第 \(j\) 个座位（对应低位的第 \(10-j\) 位）的状态加入到 \(d[i]\) 中即可。

对于没有出现在哈希表 \(d\) 中的行，我们可以任意安排 \(2\) 个家庭，因此，初始答案为 \((n - len(d)) \times 2\)。

接下来，我们遍历哈希表中每一行的状态，对于每一行，我们依次尝试安排 \(1234, 5678, 3456\) 这几种情况，如果某种情况可以安排，我们就将答案加 \(1\)。

遍历结束后，我们就得到了最终的答案。

时间复杂度 \(O(m)\)，空间复杂度 \(O(m)\)，其中 \(m\) 是 \(reservedSeats\) 的长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Solution:
    def maxNumberOfFamilies(self, n: int, reservedSeats: List[List[int]]) -> int:
        d = defaultdict(int)
        for i, j in reservedSeats:
            d[i] |= 1 << (10 - j)
        masks = (0b0111100000, 0b0000011110, 0b0001111000)
        ans = (n - len(d)) * 2
        for x in d.values():
            for mask in masks:
                if (x & mask) == 0:
                    x |= mask
                    ans += 1
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public int maxNumberOfFamilies(int n, int[][] reservedSeats) {
        Map<Integer, Integer> d = new HashMap<>();
        for (var e : reservedSeats) {
            int i = e[0], j = e[1];
            d.merge(i, 1 << (10 - j), (x, y) -> x | y);
        }
        int[] masks = {0b0111100000, 0b0000011110, 0b0001111000};
        int ans = (n - d.size()) * 2;
        for (int x : d.values()) {
            for (int mask : masks) {
                if ((x & mask) == 0) {
                    x |= mask;
                    ++ans;
                }
            }
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    int maxNumberOfFamilies(int n, vector<vector<int>>& reservedSeats) {
        unordered_map<int, int> d;
        for (auto& e : reservedSeats) {
            int i = e[0], j = e[1];
            d[i] |= 1 << (10 - j);
        }
        int masks[3] = {0b0111100000, 0b0000011110, 0b0001111000};
        int ans = (n - d.size()) * 2;
        for (auto& [_, x] : d) {
            for (int& mask : masks) {
                if ((x & mask) == 0) {
                    x |= mask;
                    ++ans;
                }
            }
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
func maxNumberOfFamilies(n int, reservedSeats [][]int) int {
    d := map[int]int{}
    for _, e := range reservedSeats {
        i, j := e[0], e[1]
        d[i] |= 1 << (10 - j)
    }
    ans := (n - len(d)) * 2
    masks := [3]int{0b0111100000, 0b0000011110, 0b0001111000}
    for _, x := range d {
        for _, mask := range masks {
            if x&mask == 0 {
                x |= mask
                ans++
            }
        }
    }
    return ans
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
function maxNumberOfFamilies(n: number, reservedSeats: number[][]): number {
    const d: Map<number, number> = new Map();
    for (const [i, j] of reservedSeats) {
        d.set(i, (d.get(i) ?? 0) | (1 << (10 - j)));
    }
    let ans = (n - d.size) << 1;
    const masks = [0b0111100000, 0b0000011110, 0b0001111000];
    for (let [_, x] of d) {
        for (const mask of masks) {
            if ((x & mask) === 0) {
                x |= mask;
                ++ans;
            }
        }
    }
    return ans;
}

评论