1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128 | struct SegmentTreeNode {
int lo;
int hi;
unique_ptr<SegmentTreeNode> left;
unique_ptr<SegmentTreeNode> right;
int max;
long sum;
SegmentTreeNode(int lo, int hi, unique_ptr<SegmentTreeNode>&& left,
unique_ptr<SegmentTreeNode>&& right, int max, long sum)
: lo(lo),
hi(hi),
left(move(left)),
right(move(right)),
max(max),
sum(sum) {}
};
class SegmentTree {
public:
explicit SegmentTree(int n, int m) : m(m), root(move(build(0, n - 1))) {}
vector<int> maxRange(int k, int maxRow) {
return maxRange(root, k, maxRow);
}
long sumRange(int maxRow) {
return sumRange(root, 0, maxRow);
}
// Minus k max and sum from seats row
void minus(int row, int k) {
minus(root, row, k);
}
private:
const int m;
unique_ptr<SegmentTreeNode> root;
unique_ptr<SegmentTreeNode> build(int l, int r) {
if (l == r)
return make_unique<SegmentTreeNode>(l, r, nullptr, nullptr, m, m);
const int mid = (l + r) / 2;
unique_ptr<SegmentTreeNode> left = build(l, mid);
unique_ptr<SegmentTreeNode> right = build(mid + 1, r);
return make_unique<SegmentTreeNode>(l, r, move(left), move(right),
max(left->max, right->max),
left->sum + right->sum);
}
vector<int> maxRange(unique_ptr<SegmentTreeNode>& root, int k, int maxRow) {
if (root->lo == root->hi) {
if (root->sum < k || root->lo > maxRow)
return {};
return {root->lo, m - static_cast<int>(root->sum)}; // {row, col}
}
// Greedily search the left subtree
if (root->left->max >= k)
return maxRange(root->left, k, maxRow);
return maxRange(root->right, k, maxRow);
}
long sumRange(unique_ptr<SegmentTreeNode>& root, int i, int j) {
if (root->lo == i && root->hi == j)
return root->sum;
const int mid = (root->lo + root->hi) / 2;
if (j <= mid)
return sumRange(root->left, i, j);
if (i > mid)
return sumRange(root->right, i, j);
return sumRange(root->left, i, mid) + sumRange(root->right, mid + 1, j);
}
void minus(unique_ptr<SegmentTreeNode>& root, int row, int k) {
if (root == nullptr)
return;
if (root->lo == root->hi && root->hi == row) {
root->max -= k;
root->sum -= k;
return;
}
const int mid = (root->lo + root->hi) / 2;
if (row <= mid)
minus(root->left, row, k);
else
minus(root->right, row, k);
root->max = max(root->left->max, root->right->max);
root->sum = root->left->sum + root->right->sum;
}
};
class BookMyShow {
public:
BookMyShow(int n, int m) : tree(n, m), seats(n, m) {}
vector<int> gather(int k, int maxRow) {
const vector<int> res = tree.maxRange(k, maxRow);
if (res.size() == 2) {
const int row = res[0];
tree.minus(row, k);
seats[row] -= k;
}
return res;
}
bool scatter(int k, int maxRow) {
if (tree.sumRange(maxRow) < k)
return false;
while (k > 0)
if (seats[minVacantRow] >= k) {
tree.minus(minVacantRow, k);
seats[minVacantRow] -= k;
k = 0;
} else {
tree.minus(minVacantRow, seats[minVacantRow]);
k -= seats[minVacantRow];
seats[minVacantRow] = 0;
++minVacantRow;
}
return true;
}
private:
SegmentTree tree;
vector<int> seats; // Remain seats at each row
int minVacantRow = 0;
};
|
