# |
Submission time |
Handle |
Problem |
Language |
Result |
Execution time |
Memory |
534319 |
2022-03-08T04:33:39 Z |
ac2hu |
Temperature (POI11_tem) |
C++14 |
|
350 ms |
47972 KB |
#include <bits/stdc++.h>
#ifdef DEBUG
#include "../templates/debug.h"
#else
#define deb(x...)
#endif
using namespace std;
template<typename T> struct rmq {
vector<T> v; int n;
static const int b = 30; // block size
vector<int> mask, t; // mask and sparse table
int op(int x, int y) {
return v[x] > v[y] ? x : y;
}
// least significant set bit
int lsb(int x) {
return x & -x;
}
// index of the most significant set bit
int msb_index(int x) {
return __builtin_clz(1)-__builtin_clz(x);
}
// answer query of v[r-size+1..r] using the masks, given size <= b
int small(int r, int size = b) {
// get only 'size' least significant bits of the mask
// and then get the index of the msb of that
int dist_from_r = msb_index(mask[r] & ((1<<size)-1));
return r - dist_from_r;
}
rmq(const vector<T>& v_) : v(v_), n(v.size()), mask(n), t(n) {
int curr_mask = 0;
for (int i = 0; i < n; i++) {
// shift mask by 1, keeping only the 'b' least significant bits
curr_mask = (curr_mask<<1) & ((1<<b)-1);
while (curr_mask > 0 and op(i, i - msb_index(lsb(curr_mask))) == i) {
// current value is smaller than the value represented by the
// last 1 in curr_mask, so we need to turn off that bit
curr_mask ^= lsb(curr_mask);
}
// append extra 1 to the mask
curr_mask |= 1;
mask[i] = curr_mask;
}
// build sparse table over the n/b blocks
// the sparse table is linearized, so what would be at
// table[j][i] is stored in table[(n/b)*j + i]
for (int i = 0; i < n/b; i++) t[i] = small(b*i+b-1);
for (int j = 1; (1<<j) <= n/b; j++) for (int i = 0; i+(1<<j) <= n/b; i++)
t[n/b*j+i] = op(t[n/b*(j-1)+i], t[n/b*(j-1)+i+(1<<(j-1))]);
}
// query(l, r) returns the actual minimum of v[l..r]
// to get the index, just change the first and last lines of the function
T query(int l, int r) {
// query too small
if (r-l+1 <= b) return v[small(r, r-l+1)];
// get the minimum of the endpoints
// (there is no problem if the ranges overlap with the sparse table query)
int ans = op(small(l+b-1), small(r));
// 'x' and 'y' are the blocks we need to query over
int x = l/b+1, y = r/b-1;
if (x <= y) {
int j = msb_index(y-x+1);
ans = op(ans, op(t[n/b*j+x], t[n/b*j+y-(1<<j)+1]));
}
return v[ans];
}
};
void scan(int &x)
{
bool neg=false;
register int c;
x =0;
c=getchar();
if(c=='-')
{
neg = true;
c=getchar();
}
for(;(c>47 && c<58);c=getchar())
x = (x<<1) + (x<<3) +c -48;
if(neg)
x *=-1;
}
const int N = 1e6 + 10;
int L[N],R[N];
int leftmost[N];
signed main() {
iostream::sync_with_stdio(false);
cin.tie(nullptr);cout.tie(nullptr);
int n;scan(n);
for(int i = 0;i<n;i++){
scan(L[i]);
scan(R[i]);
}
vector<int> temp(n);
for(int i = 0;i<n;i++)
temp[i] = L[i];
rmq<int> rq(temp);
for(int i =0;i<n;i++){
int l = 0,r = i;
while(l < r){
int mid = (l + r)/2;
if(rq.query(mid,i) <= R[i])
r = mid;
else
l = mid + 1;
}
leftmost[i] = l;
}
for(int i = 1;i<n;i++)
leftmost[i] = max(leftmost[i], leftmost[i - 1]);
int mx= 0 ;
for(int i = 0;i<n;i++){
mx = max(mx, i - leftmost[i] + 1);
}
cout << mx << "\n";
}
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
0 ms |
332 KB |
Output is correct |
2 |
Correct |
0 ms |
332 KB |
Output is correct |
3 |
Correct |
0 ms |
332 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
332 KB |
Output is correct |
2 |
Correct |
0 ms |
332 KB |
Output is correct |
3 |
Correct |
1 ms |
332 KB |
Output is correct |
4 |
Correct |
1 ms |
332 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
3 ms |
588 KB |
Output is correct |
2 |
Correct |
3 ms |
588 KB |
Output is correct |
3 |
Correct |
4 ms |
588 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
139 ms |
12888 KB |
Output is correct |
2 |
Correct |
130 ms |
14644 KB |
Output is correct |
3 |
Correct |
143 ms |
16596 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
242 ms |
20180 KB |
Output is correct |
2 |
Correct |
273 ms |
21936 KB |
Output is correct |
3 |
Runtime error |
304 ms |
33520 KB |
Memory limit exceeded |
4 |
Halted |
0 ms |
0 KB |
- |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
279 ms |
21124 KB |
Output is correct |
2 |
Correct |
239 ms |
22752 KB |
Output is correct |
3 |
Runtime error |
281 ms |
39140 KB |
Memory limit exceeded |
4 |
Halted |
0 ms |
0 KB |
- |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
350 ms |
24684 KB |
Output is correct |
2 |
Correct |
267 ms |
23268 KB |
Output is correct |
3 |
Runtime error |
330 ms |
47972 KB |
Memory limit exceeded |
4 |
Halted |
0 ms |
0 KB |
- |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
247 ms |
22560 KB |
Output is correct |
2 |
Correct |
231 ms |
23188 KB |
Output is correct |
3 |
Runtime error |
222 ms |
34288 KB |
Memory limit exceeded |
4 |
Halted |
0 ms |
0 KB |
- |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
189 ms |
22516 KB |
Output is correct |
2 |
Correct |
211 ms |
23248 KB |
Output is correct |
3 |
Correct |
182 ms |
22724 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
227 ms |
21252 KB |
Output is correct |
2 |
Correct |
209 ms |
23844 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
231 ms |
19768 KB |
Output is correct |
2 |
Correct |
295 ms |
26816 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
275 ms |
19092 KB |
Output is correct |
2 |
Correct |
241 ms |
23840 KB |
Output is correct |