| # |
Submission time |
Handle |
Problem |
Language |
Result |
Execution time |
Memory |
| 534330 |
2022-03-08T04:58:29 Z |
ac2hu |
Temperature (POI11_tem) |
C++14 |
|
277 ms |
20292 KB |
#include <bits/stdc++.h>
#ifdef DEBUG
#include "../templates/debug.h"
#else
#define deb(x...)
#endif
using namespace std;
const int N = 1e6 + 10;
int L[N],R[N];
int leftmost[N];
template<typename T> struct rmq {
int n;
static const int b = 30; // block size
vector<int> mask, t; // mask and sparse table
int op(int x, int y) {
return L[x] > L[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(int n) : n(n), 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 L[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 L[ans];
}
};
template <class T> struct is_iterator {
template <class U, typename enable_if<!is_convertible<U, const char*>::value, int>::type = 0>
constexpr static auto has_indirection(int) -> decltype(*declval<U>(), bool()) { return true; }
template <class> constexpr static bool has_indirection(long) { return false; }
constexpr static bool value = has_indirection<T>(0);
};
using uint = unsigned int;
// Buffer size should be 2^12 or 2^13 for optimal performance with files.
const uint BUFFER_SIZE = 1 << 12;
// Maximum possible length of a string representing primitive type
// assuming we won't encounter huge double values.
const uint MAX_LENGTH = 1 << 7;
namespace Detail {
struct Width { uint value; };
struct Fill { char value; };
struct Base { uint value; };
struct Precision { uint value; };
struct Delimiter { const char* value; };
} // namespace Detail
Detail::Width setWidth(uint value = 0) { return {value}; }
Detail::Fill setFill(char value = ' ') { return {value}; }
Detail::Base setBase(uint value = 10) { assert(2 <= value && value <= 36); return {value}; }
Detail::Precision setPrecision(uint value = 9) { assert(value < MAX_LENGTH); return {value}; }
Detail::Delimiter setDelimiter(const char* value = " ") { return {value}; }
/******************************* input classes ********************************/
class InputDevice {
protected:
const char* head;
const char* tail;
InputDevice(const char* head, const char* tail) : head(head), tail(tail), base(setBase().value) {}
virtual void fillInput() = 0;
inline char nextChar() {
if (__builtin_expect(head >= tail, false)) fillInput();
return *head++;
}
template <class I> int readUnsignedIntGeneral(I& arg, char c) {
I value = 0;
int length = 0;
for (;; ++length, c = nextChar()) {
if (isDigit(c)) c -= '0';
else if (isUpper(c)) c -= 'A' - 10;
else if (isLower(c)) c -= 'a' - 10;
else c = base;
if (c >= base) break;
value = base * value + c;
}
arg = value;
return --head, length;
}
template <class I> inline int readUnsignedInt(I& arg, char c) {
if (__builtin_expect(base > 10, false)) return readUnsignedIntGeneral(arg, c);
I value = 0;
int length = 0;
for (; static_cast<unsigned char>(c - '0') < base; ++length, c = nextChar())
value = base * value + c - '0';
arg = value;
return --head, length;
}
template <class I> inline bool readSignedInt(I& arg, char c) {
bool negative = c == '-';
if (negative) c = nextChar();
typename make_unsigned<I>::type unsignedArg;
if (readUnsignedInt(unsignedArg, c) == 0) return false;
arg = negative ? ~static_cast<I>(unsignedArg - 1) : static_cast<I>(unsignedArg);
return true;
}
template <class F> bool readFloatingPoint(F& arg, char c) {
bool negative = c == '-';
if (negative) c = nextChar();
unsigned long long integerPart;
if (readUnsignedInt(integerPart, c) == 0) return false;
arg = static_cast<F>(integerPart);
if (nextChar() == '.') {
unsigned long long fractionalPart = 0;
int fractionalLength = readUnsignedInt(fractionalPart, nextChar());
if (fractionalLength > 0) {
unsigned long long basePower = 1;
for (; fractionalLength; --fractionalLength) basePower *= base;
arg += static_cast<F>(fractionalPart) / basePower;
}
} else --head;
if (negative) arg = -arg;
return true;
}
public:
uint base;
InputDevice(InputDevice const&) = delete;
InputDevice& operator = (InputDevice const&) = delete;
static inline bool isSpace(char c) { return static_cast<unsigned char>(c - '\t') < 5 || c == ' '; }
static inline bool isDigit(char c) { return static_cast<unsigned char>(c - '0') < 10; }
static inline bool isUpper(char c) { return static_cast<unsigned char>(c - 'A') < 26; }
static inline bool isLower(char c) { return static_cast<unsigned char>(c - 'a') < 26; }
static inline bool isOneOf(char c, const char* str) { return strchr(str, c) != nullptr; }
void putBack() { --head; } // can be called only once directly after successfully reading a character
inline bool readChar(char& arg) {
if (__builtin_expect(head >= tail, false)) {
fillInput();
if (__builtin_expect(head >= tail, false)) return arg = '\0', false;
}
return arg = *head++, true;
}
template <class UnaryPredicate>
inline char skipCharacters(UnaryPredicate isSkipped) {
char c;
do { c = nextChar(); } while (isSkipped(c));
return c;
}
inline char skipCharacters() { return skipCharacters(isSpace); }
template <class UnaryPredicate>
inline int readString(char* arg, int limit, UnaryPredicate isTerminator) {
skipCharacters(isTerminator);
// put back first non-skipped character, reserve space for null character
int charsRead = 0;
for (--head, --limit; head < tail; fillInput()) {
ptrdiff_t chunkSize = find_if(head, min(tail, head + limit - charsRead), isTerminator) - head;
arg = copy_n(head, chunkSize, arg);
head += chunkSize;
charsRead += chunkSize;
if (chunkSize == 0 || head < tail) break;
}
return *arg = '\0', charsRead;
}
inline int readString(char* arg, int limit, const char* terminators) {
if (!*terminators) return readString(arg, limit, InputDevice::isSpace);
return readString(arg, limit, [terminators](char c) { return InputDevice::isOneOf(c, terminators); });
}
// property setters
inline bool read(Detail::Base newBase) { base = newBase.value; return true; }
// primitive types
inline bool read() { return true; }
inline bool read(char& arg) { return readChar(arg); }
template <class I> inline typename enable_if<is_integral<I>::value && is_unsigned<I>::value,
bool>::type read(I& arg) { return readUnsignedInt(arg, skipCharacters()) > 0; }
template <class I> inline typename enable_if<is_integral<I>::value && is_signed<I>::value,
bool>::type read(I& arg) { return readSignedInt(arg, skipCharacters()); }
template <class F> inline typename enable_if<is_floating_point<F>::value,
bool>::type read(F& arg) { return readFloatingPoint(arg, skipCharacters()); }
// characters skip
inline bool read(const char& arg) { skipCharacters([arg](char c) { return arg != c; }); return true; }
inline bool read(const char* arg) {
if (*arg) skipCharacters([arg](char c) { return InputDevice::isOneOf(c, arg); });
else skipCharacters();
return putBack(), true;
}
inline bool read(bool (*isSkipped)(char)) { skipCharacters(isSkipped); putBack(); return true; }
// strings
template <class I, class Terminator, class... Ts> inline typename enable_if<is_integral<I>::value,
bool>::type read(char* arg, I limit, Terminator terminator, Ts&&... args) {
readString(arg, static_cast<int>(limit), terminator);
return read(forward<Ts>(args)...);
}
template <class I> inline typename enable_if<is_integral<I>::value,
bool>::type read(char* arg, I limit) { return read(arg, limit, ""); }
template <class... Ts>
inline bool read(char* first, char* last, Ts&&... args) {
return read(first, static_cast<int>(last - first), forward<Ts>(args)...);
}
template <int N, class... Ts>
inline bool read(char (&arg)[N], Ts&&... args) { return read(static_cast<char*>(arg), N, forward<Ts>(args)...); }
template <class Terminator, class... Ts>
inline bool read(string& arg, Terminator terminator, Ts&&... args) {
for (int length = 16, last = 0;; last += length, length <<= 1) {
arg.resize(last + length);
int charsRead = readString(&arg[last], length + 1, terminator);
if (charsRead < length) {
arg.resize(last + charsRead);
return read(forward<Ts>(args)...);
}
}
}
inline bool read(string& arg) { return read(arg, ""); }
// complex types and ranges
template <class T1, class T2>
inline bool read(pair<T1, T2>& arg) { return read(arg.first, arg.second); }
template <class T>
inline bool read(complex<T>& arg) {
T real, imag;
if (!read(real, imag)) return false;
arg.real(real), arg.imag(imag);
return true;
}
template <class T>
inline bool read(vector<T>& arg) {
uint n;
if (!read(n)) return false;
arg.resize(n);
return read(arg.begin(), arg.end());
}
template <class Iterator, class... Ts> inline typename enable_if<is_iterator<Iterator>::value,
bool>::type read(Iterator first, Iterator last, Ts&&... args) {
for (; first != last; ++first) if (!read(*first)) return false;
return read(forward<Ts>(args)...);
}
template <class Iterator, class I, class... Ts>
inline typename enable_if<is_iterator<Iterator>::value && is_integral<I>::value,
bool>::type read(Iterator first, I count, Ts&&... args) { return read(first, first + count, forward<Ts>(args)...); }
// generic forwarding
template <class T>
inline auto read(T& arg) -> decltype(arg.read(*this)) { return arg.read(*this); }
template <class T0, class T1, class... Ts>
inline typename enable_if<!is_iterator<T0>::value && !is_convertible<T0, char*>::value,
bool>::type read(T0&& arg0, T1&& arg1, Ts&&... args) {
return read(forward<T0>(arg0)) && read(forward<T1>(arg1), forward<Ts>(args)...);
}
};
class InputFile : public InputDevice {
FILE* file;
bool lineBuffered;
bool owner;
char buffer[BUFFER_SIZE];
void fillInput() override {
head = buffer;
*buffer = '\0';
if (__builtin_expect(!lineBuffered, true)) {
tail = head + fread(buffer, 1, BUFFER_SIZE, file);
} else {
tail = head;
if (fgets(buffer, BUFFER_SIZE, file)) while (*tail) ++tail;
}
}
public:
InputFile(FILE* file = stdin, bool lineBuffered = true, bool takeOwnership = false)
: InputDevice(buffer, buffer) , file(file), lineBuffered(lineBuffered), owner(takeOwnership) {}
InputFile(const char* fileName) : InputFile(fopen(fileName, "r"), false, true) {}
~InputFile() { if (owner) fclose(file); }
};
// Picks up data appended to the string but doesn't handle reallocation.
class InputString : public InputDevice {
void fillInput() override { while (*tail) ++tail; }
public:
InputString(const string& s) : InputDevice(s.data(), s.data() + s.size()) {}
InputString(const char* s) : InputDevice(s, s + strlen(s)) {}
};
/******************************* output classes *******************************/
class OutputDevice {
protected:
char buffer[BUFFER_SIZE + MAX_LENGTH];
char* output;
char* end;
bool separate;
OutputDevice() : output(buffer), end(buffer + BUFFER_SIZE + MAX_LENGTH), separate(false)
, width(setWidth().value), fill(setFill().value), base(setBase().value), precision(setPrecision().value)
, delimiter(setDelimiter().value) { computeBasePower(); }
virtual void writeToDevice(uint count) = 0;
inline void flushMaybe() {
if (__builtin_expect(output >= buffer + BUFFER_SIZE, false)) {
writeToDevice(BUFFER_SIZE);
output = copy(buffer + BUFFER_SIZE, output, buffer);
}
}
void computeBasePower() {
basePower = 1;
for (uint i = 0; i < precision; ++i) basePower *= base;
}
template <class I> inline char* writeUnsignedInt(I arg, char* last) {
if (__builtin_expect(arg == 0, false)) *--last = '0';
if (__builtin_expect(base == 10, true)) {
for (; arg; arg /= 10) *--last = '0' + arg % 10;
} else for (; arg; arg /= base) {
I digit = arg % base;
*--last = digit < 10 ? '0' + digit : 'A' - 10 + digit;
}
return last;
}
template <class I> inline char* writeSignedInt(I arg, char* last) {
auto unsignedArg = static_cast<typename make_unsigned<I>::type>(arg);
if (arg < 0) {
last = writeUnsignedInt(~unsignedArg + 1, last);
*--last = '-';
return last;
}
return writeUnsignedInt(unsignedArg, last);
}
template <class F> char* writeFloatingPoint(F arg, char* last) {
bool negative = signbit(arg);
if (negative) arg = -arg;
if (isnan(arg)) for (int i = 0; i < 3; ++i) *--last = i["NaN"];
else if (isinf(arg)) for (int i = 0; i < 3; ++i) *--last = i["fnI"];
else {
auto integerPart = static_cast<unsigned long long>(arg);
auto fractionalPart = static_cast<unsigned long long>((arg - integerPart) * basePower + F(0.5));
if (fractionalPart >= basePower) ++integerPart, fractionalPart = 0;
char* point = last - precision;
if (precision > 0) {
::fill(point, writeUnsignedInt(fractionalPart, last), '0');
*--point = '.';
}
last = writeUnsignedInt(integerPart, point);
}
if (negative) *--last = '-';
return last;
}
inline int writeT(char* first) {
int delimiterLenght = separate ? writeDelimiter() : 0;
separate = true;
uint charsWritten = static_cast<uint>(end - first);
if (__builtin_expect(charsWritten < width, false))
charsWritten += writeFill(width - charsWritten);
output = copy(first, end, output);
flushMaybe();
return delimiterLenght + static_cast<int>(charsWritten);
}
inline int writeFill(uint count) {
int charsWritten = static_cast<int>(count);
if (__builtin_expect(output + count + MAX_LENGTH < end, true)) {
if (count == 1) *output++ = fill;
else output = fill_n(output, count, fill);
} else for (uint chunkSize = static_cast<uint>(buffer + BUFFER_SIZE - output);; chunkSize = BUFFER_SIZE) {
if (chunkSize > count) chunkSize = count;
output = fill_n(output, chunkSize, fill);
flushMaybe();
if ((count -= chunkSize) == 0) break;
}
return charsWritten;
}
public:
uint width;
char fill;
uint base;
uint precision;
unsigned long long basePower;
string delimiter;
OutputDevice(OutputDevice const&) = delete;
OutputDevice& operator = (OutputDevice const&) = delete;
virtual ~OutputDevice() {};
inline int writeChar(char arg) { separate = false; *output++ = arg; flushMaybe(); return 1; }
inline int writeString(const char* arg, size_t length, bool checkWidth = true) {
separate = false;
uint count = static_cast<uint>(length);
int charsWritten = static_cast<int>(count) + (checkWidth && count < width ? writeFill(width - count) : 0);
if (__builtin_expect(output + count + MAX_LENGTH < end, true)) {
if (count == 1) *output++ = *arg;
else output = copy_n(arg, count, output);
} else for (uint chunkSize = static_cast<uint>(buffer + BUFFER_SIZE - output);; chunkSize = BUFFER_SIZE) {
if (chunkSize > count) chunkSize = count;
output = copy_n(arg, chunkSize, output);
flushMaybe();
if ((count -= chunkSize) == 0) break;
arg += chunkSize;
}
return charsWritten;
}
inline int writeDelimiter() { return writeString(delimiter.c_str(), delimiter.size(), false); }
inline void flush() {
writeToDevice(static_cast<uint>(output - buffer));
output = buffer;
}
// property setters
inline int write(Detail::Width newWidth) { width = newWidth.value; return 0; }
inline int write(Detail::Fill newFill) { fill = newFill.value; return 0; }
inline int write(Detail::Base newBase) { base = newBase.value; computeBasePower(); return 0; }
inline int write(Detail::Precision newPrecision) {
precision = newPrecision.value; computeBasePower(); return 0;
}
inline int write(Detail::Delimiter newDelimiter) { delimiter = newDelimiter.value; return 0; }
// primitive types
inline int write() { return 0; }
inline int write(char arg) { return writeChar(arg); }
template <class I> inline typename enable_if<is_integral<I>::value && is_unsigned<I>::value,
int>::type write(I arg) { return writeT(writeUnsignedInt(arg, end)); }
template <class I> inline typename enable_if<is_integral<I>::value && is_signed<I>::value,
int>::type write(I arg) { return writeT(writeSignedInt(arg, end)); }
template <class F> inline typename enable_if<is_floating_point<F>::value,
int>::type write(F arg) { return writeT(writeFloatingPoint(arg, end)); }
// complex types
inline int write(const char* arg) { return writeString(arg, strlen(arg)); }
template <int N>
inline int write(char (&arg)[N]) { return writeString(arg, strlen(arg)); }
inline int write(const string& arg) { return writeString(arg.c_str(), arg.size()); }
template <class T1, class T2>
inline int write(const pair<T1, T2>& arg) {
int charsWritten = write(arg.first);
charsWritten += writeDelimiter();
return charsWritten + write(arg.second);
}
template <class T>
inline int write(const complex<T>& arg) { return write(real(arg), imag(arg)); }
// ranges
template <class Iterator, class... Ts> inline typename enable_if<is_iterator<Iterator>::value,
int>::type write(Iterator first, Iterator last, Ts&&... args) {
int charsWritten = 0;
for (; first != last; charsWritten += ++first == last ? 0 : writeDelimiter()) charsWritten += write(*first);
return charsWritten + write(forward<Ts>(args)...);
}
template <class Iterator, class I, class... Ts>
inline typename enable_if<is_iterator<Iterator>::value && is_integral<I>::value,
int>::type write(Iterator first, I count, Ts&&... args) { return write(first, first + count, forward<Ts>(args)...); }
// generic forwarding
template <class T>
inline auto write(const T& arg) -> decltype(arg.write(*this)) { return arg.write(*this); }
template <class T0, class T1, class... Ts> inline typename enable_if<!is_iterator<T0>::value,
int>::type write(T0&& arg0, T1&& arg1, Ts&&... args) {
int charsWritten = write(forward<T0>(arg0));
return charsWritten + write(forward<T1>(arg1), forward<Ts>(args)...);
}
};
class OutputFile : public OutputDevice {
FILE* file;
bool owner;
void writeToDevice(uint count) override {
fwrite(buffer, 1, count, file);
fflush(file);
}
public:
OutputFile(FILE* file = stdout, bool takeOwnership = false) : file(file), owner(takeOwnership) {}
OutputFile(const char* fileName) : OutputFile(fopen(fileName, "w"), true) {}
~OutputFile() override { flush(); if (owner) fclose(file); }
};
class OutputString : public OutputDevice {
string& str;
void writeToDevice(uint count) override { str.append(buffer, count); }
public:
OutputString(string& str) : OutputDevice(), str(str) {}
~OutputString() override { flush(); }
};
unique_ptr<InputDevice> input;
unique_ptr<OutputDevice> output;
template <class... Ts> inline bool read(Ts&&... args) { return input->read(forward<Ts>(args)...); }
template <class... Ts> inline int write(Ts&&... args) { return output->write(forward<Ts>(args)...); }
template <class... Ts> inline int writeln(Ts&&... args) { return write(forward<Ts>(args)..., '\n'); }
void flush() { output->flush(); }
signed main() {
iostream::sync_with_stdio(false);
cin.tie(nullptr);cout.tie(nullptr);
input.reset(new InputFile(stdin,false));
output.reset(new OutputFile());
int n; read(n);
for(int i = 0;i<n;i++){
read(L[i], R[i]);
// L[i] = sc.readInt();
// R[i] = sc.readInt();
}
// for(int i =0 ;i<n;i++)
// cout << L[i] << " " << R[i] << "\n";
rmq<int> rq(n);
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);
}
writeln(mx);
}
Compilation message
tem.cpp: In instantiation of 'int InputDevice::readUnsignedIntGeneral(I&, char) [with I = unsigned int]':
tem.cpp:140:74: required from 'int InputDevice::readUnsignedInt(I&, char) [with I = unsigned int]'
tem.cpp:153:24: required from 'bool InputDevice::readSignedInt(I&, char) [with I = int]'
tem.cpp:235:50: required from 'typename std::enable_if<(std::is_integral<_Tp>::value && std::is_signed<_Tp>::value), bool>::type InputDevice::read(I&) [with I = int; typename std::enable_if<(std::is_integral<_Tp>::value && std::is_signed<_Tp>::value), bool>::type = bool]'
tem.cpp:548:75: required from 'bool read(Ts&& ...) [with Ts = {int&}]'
tem.cpp:557:15: required from here
tem.cpp:132:13: warning: comparison of integer expressions of different signedness: 'char' and 'uint' {aka 'unsigned int'} [-Wsign-compare]
132 | if (c >= base) break;
| ~~^~~~~~~
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
1 ms |
332 KB |
Output is correct |
| 2 |
Correct |
1 ms |
332 KB |
Output is correct |
| 3 |
Correct |
0 ms |
332 KB |
Output is correct |
| # |
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 |
| 4 |
Correct |
1 ms |
332 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
2 ms |
460 KB |
Output is correct |
| 2 |
Correct |
2 ms |
460 KB |
Output is correct |
| 3 |
Correct |
2 ms |
588 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
112 ms |
9308 KB |
Output is correct |
| 2 |
Correct |
144 ms |
10516 KB |
Output is correct |
| 3 |
Correct |
125 ms |
11932 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
184 ms |
14492 KB |
Output is correct |
| 2 |
Correct |
187 ms |
15884 KB |
Output is correct |
| 3 |
Correct |
188 ms |
16592 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
222 ms |
15264 KB |
Output is correct |
| 2 |
Correct |
242 ms |
16460 KB |
Output is correct |
| 3 |
Correct |
189 ms |
17028 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
269 ms |
17744 KB |
Output is correct |
| 2 |
Correct |
177 ms |
16848 KB |
Output is correct |
| 3 |
Correct |
277 ms |
20292 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
195 ms |
16148 KB |
Output is correct |
| 2 |
Correct |
225 ms |
16828 KB |
Output is correct |
| 3 |
Correct |
187 ms |
16852 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
168 ms |
16148 KB |
Output is correct |
| 2 |
Correct |
187 ms |
16484 KB |
Output is correct |
| 3 |
Correct |
182 ms |
16132 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
187 ms |
15296 KB |
Output is correct |
| 2 |
Correct |
191 ms |
16964 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
195 ms |
14188 KB |
Output is correct |
| 2 |
Correct |
224 ms |
19144 KB |
Output is correct |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
205 ms |
13724 KB |
Output is correct |
| 2 |
Correct |
196 ms |
17108 KB |
Output is correct |
