oj.uz

답안 #402987

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
402987 2021-05-12T15:58:52 Z mjhmjh1104 유괴 2 (JOI17_abduction2) C++14
44 / 100
 5000 ms 8716 KB 
#include <map>
#include <tuple>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

int tree_a[131072], tree_b[131072];
vector<tuple<int, int, int>> tv;

void interval_front(int i, int b, int e, int l, int r) {
    if (r < b || e < l) return;
    if (l <= b && e <= r) {
        tv.push_back({ i, b, e });
        return;
    }
    int m = (b + e) / 2;
    interval_front(i * 2 + 1, b, m, l, r);
    interval_front(i * 2 + 2, m + 1, e, l, r);
}

void interval_back(int i, int b, int e, int l, int r) {
    if (r < b || e < l) return;
    if (l <= b && e <= r) {
        tv.push_back({ i, b, e });
        return;
    }
    int m = (b + e) / 2;
    interval_back(i * 2 + 2, m + 1, e, l, r);
    interval_back(i * 2 + 1, b, m, l, r);
}

int lower_bound_left_real_a(int i, int b, int e, int v) {
    if (b == e) return b;
    int m = (b + e) / 2;
    if (tree_a[i * 2 + 2] > v) return lower_bound_left_real_a(i * 2 + 2, m + 1, e, v);
    return lower_bound_left_real_a(i * 2 + 1, b, m, v);
}

int lower_bound_left_real_b(int i, int b, int e, int v) {
    if (b == e) return b;
    int m = (b + e) / 2;
    if (tree_b[i * 2 + 2] > v) return lower_bound_left_real_b(i * 2 + 2, m + 1, e, v);
    return lower_bound_left_real_b(i * 2 + 1, b, m, v);
}

int lower_bound_right_real_a(int i, int b, int e, int v) {
    if (b == e) return b;
    int m = (b + e) / 2;
    if (tree_a[i * 2 + 1] > v) return lower_bound_right_real_a(i * 2 + 1, b, m, v);
    return lower_bound_right_real_a(i * 2 + 2, m + 1, e, v);
}

int lower_bound_right_real_b(int i, int b, int e, int v) {
    if (b == e) return b;
    int m = (b + e) / 2;
    if (tree_b[i * 2 + 1] > v) return lower_bound_right_real_b(i * 2 + 1, b, m, v);
    return lower_bound_right_real_b(i * 2 + 2, m + 1, e, v);
}

int lower_bound_left_a(int x, int v) {
    tv.clear();
    interval_back(0, 0, 65535, 0, x);
    for (auto &i: tv) {
        auto [ a, b, c ] = i;
        if (tree_a[a] > v) return lower_bound_left_real_a(a, b, c, v);
    }
    return -1;
}

int lower_bound_left_b(int x, int v) {
    tv.clear();
    interval_back(0, 0, 65535, 0, x);
    for (auto &i: tv) {
        auto [ a, b, c ] = i;
        if (tree_b[a] > v) return lower_bound_left_real_b(a, b, c, v);
    }
    return -1;
}

int lower_bound_right_a(int x, int v) {
    tv.clear();
    interval_front(0, 0, 65535, x, 65535);
    for (auto &i: tv) {
        auto [ a, b, c ] = i;
        if (tree_a[a] > v) return lower_bound_right_real_a(a, b, c, v);
    }
    return 65536;
}

int lower_bound_right_b(int x, int v) {
    tv.clear();
    interval_front(0, 0, 65535, x, 65535);
    for (auto &i: tv) {
        auto [ a, b, c ] = i;
        if (tree_b[a] > v) return lower_bound_right_real_b(a, b, c, v);
    }
    return 65536;
}

int h, w, q;
int a[50006], b[50006];
pair<int, bool> lt[100006];
vector<pair<int, long long>> v[100006];
vector<int> compress;

int main() {
    scanf("%d%d%d", &w, &h, &q);
    for (int i = 0; i < w; i++) scanf("%d", a + i);
    for (int i = 0; i < h; i++) scanf("%d", b + i);
    for (int i = 0; i < w; i++) compress.push_back(a[i]);
    for (int i = 0; i < h; i++) compress.push_back(b[i]);
    sort(compress.begin(), compress.end());
    for (int i = 0; i < w; i++) a[i] = lower_bound(compress.begin(), compress.end(), a[i]) - compress.begin();
    for (int i = 0; i < h; i++) b[i] = lower_bound(compress.begin(), compress.end(), b[i]) - compress.begin();
    for (int i = 0; i < w; i++) lt[a[i]] = { i, false };
    for (int i = 0; i < h; i++) lt[b[i]] = { i, true };
    for (int i = 0; i < w; i++) tree_a[65535 + i] = a[i];
    for (int i = 0; i < h; i++) tree_b[65535 + i] = b[i];
    for (int i = 65534; i >= 0; i--) {
        tree_a[i] = max(tree_a[i * 2 + 1], tree_a[i * 2 + 2]);
        tree_b[i] = max(tree_b[i * 2 + 1], tree_b[i * 2 + 2]);
    }
    for (int i = 0; i < q; i++) {
        int s, t;
        scanf("%d%d", &t, &s);
        s--, t--;
        long long res = 0;
        if (s > 0) { // up
            for (int j = 0; j < h + w; j++) v[j].clear();
            int it = lower_bound_left_b(s - 1, a[t]);
            if (it < 0) res = max(res, (long long)s);
            else {
                v[b[it]].push_back({ t, s - it });
                for (int i = 0; i < h + w; i++) if (!v[i].empty()) {
                    if (!lt[i].second) {
                        int above = lower_bound_left_b(v[i].front().first, a[lt[i].first]), bottom = lower_bound_right_b(v[i].front().first, a[lt[i].first]);
                        if (above < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[b[above]].empty() && lower_bound_left_a(v[b[above]].front().first, b[above]) != lower_bound_left_a(lt[i].first, b[above])) v[b[above]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - above));
                            v[b[above]].push_back({ lt[i].first, ret });
                        }
                        if (bottom >= 65536) for (auto &j: v[i]) res = max(res, j.second + (h - 1 - j.first));
                        else {
                            if (!v[b[bottom]].empty() && lower_bound_left_a(v[b[bottom]].front().first, b[bottom]) != lower_bound_left_a(lt[i].first, b[bottom])) v[b[bottom]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (bottom - j.first));
                            v[b[bottom]].push_back({ lt[i].first, ret });
                        }
                    } else {
                        int left = lower_bound_left_a(v[i].front().first, b[lt[i].first]), right = lower_bound_right_a(v[i].front().first, b[lt[i].first]);
                        if (left < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[a[left]].empty() && lower_bound_left_b(v[a[left]].front().first, a[left]) != lower_bound_left_b(lt[i].first, a[left])) v[a[left]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - left));
                            v[a[left]].push_back({ lt[i].first, ret });
                        }
                        if (right >= 65536) for (auto &j: v[i]) res = max(res, j.second + (w - 1 - j.first));
                        else {
                            if (!v[a[right]].empty() && lower_bound_left_b(v[a[right]].front().first, a[right]) != lower_bound_left_b(lt[i].first, a[right])) v[a[right]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (right - j.first));
                            v[a[right]].push_back({ lt[i].first, ret });
                        }
                    }
                }
            }
        }
        if (s < h - 1) { // down
            for (int j = 0; j < h + w; j++) v[j].clear();
            int it = lower_bound_right_b(s + 1, a[t]);
            if (it >= 65536) res = max(res, (long long)(h - 1 - s));
            else {
                v[b[it]].push_back({ t, it - s });
                for (int i = 0; i < h + w; i++) if (!v[i].empty()) {
                    if (!lt[i].second) {
                        int above = lower_bound_left_b(v[i].front().first, a[lt[i].first]), bottom = lower_bound_right_b(v[i].front().first, a[lt[i].first]);
                        if (above < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[b[above]].empty() && lower_bound_left_a(v[b[above]].front().first, b[above]) != lower_bound_left_a(lt[i].first, b[above])) v[b[above]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - above));
                            v[b[above]].push_back({ lt[i].first, ret });
                        }
                        if (bottom >= 65536) for (auto &j: v[i]) res = max(res, j.second + (h - 1 - j.first));
                        else {
                            if (!v[b[bottom]].empty() && lower_bound_left_a(v[b[bottom]].front().first, b[bottom]) != lower_bound_left_a(lt[i].first, b[bottom])) v[b[bottom]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (bottom - j.first));
                            v[b[bottom]].push_back({ lt[i].first, ret });
                        }
                    } else {
                        int left = lower_bound_left_a(v[i].front().first, b[lt[i].first]), right = lower_bound_right_a(v[i].front().first, b[lt[i].first]);
                        if (left < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[a[left]].empty() && lower_bound_left_b(v[a[left]].front().first, a[left]) != lower_bound_left_b(lt[i].first, a[left])) v[a[left]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - left));
                            v[a[left]].push_back({ lt[i].first, ret });
                        }
                        if (right >= 65536) for (auto &j: v[i]) res = max(res, j.second + (w - 1 - j.first));
                        else {
                            if (!v[a[right]].empty() && lower_bound_left_b(v[a[right]].front().first, a[right]) != lower_bound_left_b(lt[i].first, a[right])) v[a[right]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (right - j.first));
                            v[a[right]].push_back({ lt[i].first, ret });
                        }
                    }
                }
            }
        }
        if (t > 0) { // left
            for (int j = 0; j < h + w; j++) v[j].clear();
            int it = lower_bound_left_a(t - 1, b[s]);
            if (it < 0) res = max(res, (long long)t);
            else {
                v[a[it]].push_back({ s, t - it });
                for (int i = 0; i < h + w; i++) if (!v[i].empty()) {
                    if (!lt[i].second) {
                        int above = lower_bound_left_b(v[i].front().first, a[lt[i].first]), bottom = lower_bound_right_b(v[i].front().first, a[lt[i].first]);
                        if (above < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[b[above]].empty() && lower_bound_left_a(v[b[above]].front().first, b[above]) != lower_bound_left_a(lt[i].first, b[above])) v[b[above]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - above));
                            v[b[above]].push_back({ lt[i].first, ret });
                        }
                        if (bottom >= 65536) for (auto &j: v[i]) res = max(res, j.second + (h - 1 - j.first));
                        else {
                            if (!v[b[bottom]].empty() && lower_bound_left_a(v[b[bottom]].front().first, b[bottom]) != lower_bound_left_a(lt[i].first, b[bottom])) v[b[bottom]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (bottom - j.first));
                            v[b[bottom]].push_back({ lt[i].first, ret });
                        }
                    } else {
                        int left = lower_bound_left_a(v[i].front().first, b[lt[i].first]), right = lower_bound_right_a(v[i].front().first, b[lt[i].first]);
                        if (left < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[a[left]].empty() && lower_bound_left_b(v[a[left]].front().first, a[left]) != lower_bound_left_b(lt[i].first, a[left])) v[a[left]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - left));
                            v[a[left]].push_back({ lt[i].first, ret });
                        }
                        if (right >= 65536) for (auto &j: v[i]) res = max(res, j.second + (w - 1 - j.first));
                        else {
                            if (!v[a[right]].empty() && lower_bound_left_b(v[a[right]].front().first, a[right]) != lower_bound_left_b(lt[i].first, a[right])) v[a[right]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (right - j.first));
                            v[a[right]].push_back({ lt[i].first, ret });
                        }
                    }
                }
            }
        }
        if (t < w - 1) { // right
            for (int j = 0; j < h + w; j++) v[j].clear();
            int it = lower_bound_right_a(t + 1, b[s]);
            if (it >= 65536) res = max(res, (long long)(w - 1 - t));
            else {
                v[a[it]].push_back({ s, it - t });
                for (int i = 0; i < h + w; i++) if (!v[i].empty()) {
                    if (!lt[i].second) {
                        int above = lower_bound_left_b(v[i].front().first, a[lt[i].first]), bottom = lower_bound_right_b(v[i].front().first, a[lt[i].first]);
                        if (above < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[b[above]].empty() && lower_bound_left_a(v[b[above]].front().first, b[above]) != lower_bound_left_a(lt[i].first, b[above])) v[b[above]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - above));
                            v[b[above]].push_back({ lt[i].first, ret });
                        }
                        if (bottom >= 65536) for (auto &j: v[i]) res = max(res, j.second + (h - 1 - j.first));
                        else {
                            if (!v[b[bottom]].empty() && lower_bound_left_a(v[b[bottom]].front().first, b[bottom]) != lower_bound_left_a(lt[i].first, b[bottom])) v[b[bottom]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (bottom - j.first));
                            v[b[bottom]].push_back({ lt[i].first, ret });
                        }
                    } else {
                        int left = lower_bound_left_a(v[i].front().first, b[lt[i].first]), right = lower_bound_right_a(v[i].front().first, b[lt[i].first]);
                        if (left < 0) for (auto &j: v[i]) res = max(res, j.second + j.first);
                        else {
                            if (!v[a[left]].empty() && lower_bound_left_b(v[a[left]].front().first, a[left]) != lower_bound_left_b(lt[i].first, a[left])) v[a[left]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (j.first - left));
                            v[a[left]].push_back({ lt[i].first, ret });
                        }
                        if (right >= 65536) for (auto &j: v[i]) res = max(res, j.second + (w - 1 - j.first));
                        else {
                            if (!v[a[right]].empty() && lower_bound_left_b(v[a[right]].front().first, a[right]) != lower_bound_left_b(lt[i].first, a[right])) v[a[right]].clear();
                            long long ret = 0;
                            for (auto &j: v[i]) ret = max(ret, j.second + (right - j.first));
                            v[a[right]].push_back({ lt[i].first, ret });
                        }
                    }
                }
            }
        }
        printf("%lld\n", res);
    }
}

Compilation message

abduction2.cpp: In function 'int lower_bound_left_a(int, int)':
abduction2.cpp:65:14: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
   65 |         auto [ a, b, c ] = i;
      |              ^
abduction2.cpp: In function 'int lower_bound_left_b(int, int)':
abduction2.cpp:75:14: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
   75 |         auto [ a, b, c ] = i;
      |              ^
abduction2.cpp: In function 'int lower_bound_right_a(int, int)':
abduction2.cpp:85:14: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
   85 |         auto [ a, b, c ] = i;
      |              ^
abduction2.cpp: In function 'int lower_bound_right_b(int, int)':
abduction2.cpp:95:14: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
   95 |         auto [ a, b, c ] = i;
      |              ^
abduction2.cpp: In function 'int main()':
abduction2.cpp:108:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  108 |     scanf("%d%d%d", &w, &h, &q);
      |     ~~~~~^~~~~~~~~~~~~~~~~~~~~~
abduction2.cpp:109:38: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  109 |     for (int i = 0; i < w; i++) scanf("%d", a + i);
      |                                 ~~~~~^~~~~~~~~~~~~
abduction2.cpp:110:38: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  110 |     for (int i = 0; i < h; i++) scanf("%d", b + i);
      |                                 ~~~~~^~~~~~~~~~~~~
abduction2.cpp:126:14: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  126 |         scanf("%d%d", &t, &s);
      |         ~~~~~^~~~~~~~~~~~~~~~

Subtask #1
13.0 / 13.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 3148 KB Output is correct
2 Correct 2 ms 3148 KB Output is correct
3 Correct 3 ms 3148 KB Output is correct
4 Correct 2 ms 3148 KB Output is correct
5 Correct 2 ms 3148 KB Output is correct
6 Correct 2 ms 3148 KB Output is correct
7 Correct 2 ms 3148 KB Output is correct
8 Correct 2 ms 3148 KB Output is correct
9 Correct 2 ms 3148 KB Output is correct
10 Correct 2 ms 3148 KB Output is correct
11 Correct 2 ms 3148 KB Output is correct

Subtask #2
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 3148 KB Output is correct
2 Correct 2 ms 3148 KB Output is correct
3 Correct 3 ms 3148 KB Output is correct
4 Correct 2 ms 3148 KB Output is correct
5 Correct 2 ms 3148 KB Output is correct
6 Correct 2 ms 3148 KB Output is correct
7 Correct 2 ms 3148 KB Output is correct
8 Correct 2 ms 3148 KB Output is correct
9 Correct 2 ms 3148 KB Output is correct
10 Correct 2 ms 3148 KB Output is correct
11 Correct 2 ms 3148 KB Output is correct
12 Correct 4 ms 3148 KB Output is correct
13 Correct 4 ms 3148 KB Output is correct
14 Correct 3 ms 3148 KB Output is correct
15 Correct 4 ms 3148 KB Output is correct
16 Correct 3 ms 3148 KB Output is correct
17 Correct 4 ms 3256 KB Output is correct
18 Correct 4 ms 3148 KB Output is correct
19 Correct 8 ms 3300 KB Output is correct
20 Correct 10 ms 3332 KB Output is correct
21 Correct 8 ms 3276 KB Output is correct
22 Correct 12 ms 3276 KB Output is correct

Subtask #3
17.0 / 17.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 3148 KB Output is correct
2 Correct 2 ms 3148 KB Output is correct
3 Correct 3 ms 3148 KB Output is correct
4 Correct 2 ms 3148 KB Output is correct
5 Correct 2 ms 3148 KB Output is correct
6 Correct 2 ms 3148 KB Output is correct
7 Correct 2 ms 3148 KB Output is correct
8 Correct 2 ms 3148 KB Output is correct
9 Correct 2 ms 3148 KB Output is correct
10 Correct 2 ms 3148 KB Output is correct
11 Correct 2 ms 3148 KB Output is correct
12 Correct 4 ms 3148 KB Output is correct
13 Correct 4 ms 3148 KB Output is correct
14 Correct 3 ms 3148 KB Output is correct
15 Correct 4 ms 3148 KB Output is correct
16 Correct 3 ms 3148 KB Output is correct
17 Correct 4 ms 3256 KB Output is correct
18 Correct 4 ms 3148 KB Output is correct
19 Correct 8 ms 3300 KB Output is correct
20 Correct 10 ms 3332 KB Output is correct
21 Correct 8 ms 3276 KB Output is correct
22 Correct 12 ms 3276 KB Output is correct
23 Correct 43 ms 5188 KB Output is correct
24 Correct 40 ms 5132 KB Output is correct
25 Correct 40 ms 5216 KB Output is correct
26 Correct 40 ms 5220 KB Output is correct
27 Correct 40 ms 5188 KB Output is correct
28 Correct 69 ms 6048 KB Output is correct
29 Correct 38 ms 5220 KB Output is correct
30 Correct 160 ms 6868 KB Output is correct
31 Correct 190 ms 7484 KB Output is correct
32 Correct 37 ms 5124 KB Output is correct
33 Correct 67 ms 5600 KB Output is correct

Subtask #4
4.0 / 4.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 3256 KB Output is correct
2 Correct 12 ms 3276 KB Output is correct
3 Correct 11 ms 3272 KB Output is correct
4 Correct 12 ms 3264 KB Output is correct
5 Correct 12 ms 3268 KB Output is correct
6 Correct 91 ms 3392 KB Output is correct
7 Correct 76 ms 3280 KB Output is correct
8 Correct 284 ms 3372 KB Output is correct
9 Correct 309 ms 3372 KB Output is correct
10 Correct 350 ms 3364 KB Output is correct
11 Correct 444 ms 3460 KB Output is correct

Subtask #5
0 / 56.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 3148 KB Output is correct
2 Correct 2 ms 3148 KB Output is correct
3 Correct 3 ms 3148 KB Output is correct
4 Correct 2 ms 3148 KB Output is correct
5 Correct 2 ms 3148 KB Output is correct
6 Correct 2 ms 3148 KB Output is correct
7 Correct 2 ms 3148 KB Output is correct
8 Correct 2 ms 3148 KB Output is correct
9 Correct 2 ms 3148 KB Output is correct
10 Correct 2 ms 3148 KB Output is correct
11 Correct 2 ms 3148 KB Output is correct
12 Correct 4 ms 3148 KB Output is correct
13 Correct 4 ms 3148 KB Output is correct
14 Correct 3 ms 3148 KB Output is correct
15 Correct 4 ms 3148 KB Output is correct
16 Correct 3 ms 3148 KB Output is correct
17 Correct 4 ms 3256 KB Output is correct
18 Correct 4 ms 3148 KB Output is correct
19 Correct 8 ms 3300 KB Output is correct
20 Correct 10 ms 3332 KB Output is correct
21 Correct 8 ms 3276 KB Output is correct
22 Correct 12 ms 3276 KB Output is correct
23 Correct 43 ms 5188 KB Output is correct
24 Correct 40 ms 5132 KB Output is correct
25 Correct 40 ms 5216 KB Output is correct
26 Correct 40 ms 5220 KB Output is correct
27 Correct 40 ms 5188 KB Output is correct
28 Correct 69 ms 6048 KB Output is correct
29 Correct 38 ms 5220 KB Output is correct
30 Correct 160 ms 6868 KB Output is correct
31 Correct 190 ms 7484 KB Output is correct
32 Correct 37 ms 5124 KB Output is correct
33 Correct 67 ms 5600 KB Output is correct
34 Correct 12 ms 3256 KB Output is correct
35 Correct 12 ms 3276 KB Output is correct
36 Correct 11 ms 3272 KB Output is correct
37 Correct 12 ms 3264 KB Output is correct
38 Correct 12 ms 3268 KB Output is correct
39 Correct 91 ms 3392 KB Output is correct
40 Correct 76 ms 3280 KB Output is correct
41 Correct 284 ms 3372 KB Output is correct
42 Correct 309 ms 3372 KB Output is correct
43 Correct 350 ms 3364 KB Output is correct
44 Correct 444 ms 3460 KB Output is correct
45 Correct 154 ms 5212 KB Output is correct
46 Correct 152 ms 5216 KB Output is correct
47 Correct 154 ms 5220 KB Output is correct
48 Correct 150 ms 5220 KB Output is correct
49 Correct 162 ms 5180 KB Output is correct
50 Correct 1936 ms 6488 KB Output is correct
51 Correct 1712 ms 6584 KB Output is correct
52 Execution timed out 5080 ms 8716 KB Time limit exceeded
53 Halted 0 ms 0 KB -