oj.uz

Submission #876514

# Submission time Handle Problem Language Result Execution time Memory
876514 2023-11-21T21:11:56 Z danikoynov Fish 2 (JOI22_fish2) C++14
48 / 100
 4000 ms 88948 KB 
#include<bits/stdc++.h>
#define endl '\n'

using namespace std;

typedef long long ll;

const int maxn = 1e5 + 10;


int n, q;
ll a[maxn], pref[maxn];
void input()
{
    cin >> n;
    for (int i = 1; i <= n; i ++)
        cin >> a[i];
    cin >> q;
    a[0] = 1e9 + 10;
    a[n + 1] = 1e9 + 10;

}

struct interval
{
    int left, right, pivot;

    interval(int _left = 0, int _right = 0, int _pivot = 0)
    {
        left = _left;
        right = _right;
        pivot = _pivot;
    }
    bool operator < (const interval &it) const
    {
        if (left != it.left)
            return left < it.left;
        if (right != it.right)
            return right < it.right;
        ///assert(pivot != it.pivot);
        return pivot < it.pivot;
    }
};

set < interval > ranges;
vector < interval > act[4 * maxn];

void add_range(int root, int left, int right, int qleft, int qright, interval cur)
{
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        //cout << "ROOT " << root << endl;
        act[root].push_back(cur);

        return;
    }

    int mid = (left + right) / 2;
    add_range(root * 2, left, mid, qleft, qright, cur);
    add_range(root * 2 + 1, mid + 1, right, qleft, qright, cur);
}

void rem_range(int root, int left, int right, int qleft, int qright)
{
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        act[root].pop_back();
        return;
    }

    int mid = (left + right) / 2;
    rem_range(root * 2, left, mid, qleft, qright);
    rem_range(root * 2 + 1, mid + 1, right, qleft, qright);
}

bool cmp_interval(const interval &it1, const interval &it2)
{
    if ((it1.right - it1.left) != (it2.right - it2.left))
        return (it1.right - it1.left) < (it2.right - it2.left);
    if (it1.left != it2.left)
        return it1.left < it2.left;

    /**if (it1.pivot == it2.pivot)
    {
        cout << "here" << endl;
        cout << it1.left << " " << it1.right << " " << it1.pivot << endl;
        cout << it2.left << " " << it2.right << " " << it2.pivot << endl;
        cout << "FUCK" << endl;
        exit(0);
    }*/
    return (it1.pivot < it2.pivot);
}

set < interval > pact[maxn];
void get_ranges()
{
    ranges.clear();
    stack < int > st;
    st.push(0);
    vector < interval > vec;
    for (int i = 1; i <= n; i ++)
    {
        while(!st.empty() && a[st.top()] < a[i])
            st.pop();

        ranges.insert(interval(st.top(), i, i));
        vec.push_back(interval(st.top(), i, i));


        st.push(i);
    }

    while(!st.empty())
        st.pop();
    st.push(n + 1);
    for (int i = n; i > 0; i --)
    {
        while(!st.empty() && a[st.top()] < a[i])
            st.pop();

        ranges.insert(interval(i, st.top(), i));
        vec.push_back(interval(i, st.top(), i));

        st.push(i);
    }

    sort(vec.begin(), vec.end(), cmp_interval);
    ///reverse(vec.begin(), vec.end());
    for (interval cur : vec)
    {
        //cout << "added " << cur.left << " " << cur.right << endl;
        pact[cur.left].insert(cur);
        pact[cur.right].insert(cur);
        add_range(1, 0, n + 1, cur.left + 1, cur.right - 1, cur);
    }
}

int b[maxn];

struct node
{
    int cnt, mx;

    node(int _cnt = 0, int _mx = 1e9 + 10)
    {
        cnt = _cnt;
        mx = _mx;
    }
};

node tree[4 * maxn];
int lazy[4 * maxn];

node merge_node(node lf, node rf)
{
    if (lf.cnt == -1 || rf.mx < lf.mx)
        return rf;
    if (rf.cnt == -1 || lf.mx < rf.mx)
        return lf;

    return node(lf.cnt + rf.cnt, lf.mx);
}

void push_lazy(int root, int left, int right)
{
    tree[root].mx += lazy[root];
    if (left != right)
    {
        lazy[root * 2] += lazy[root];
        lazy[root * 2 + 1] += lazy[root];
    }
    lazy[root] = 0;
}

void build_tree(int root, int left, int right)
{
    lazy[root] = 0;
    if (left == right)
    {
        tree[root].mx = b[left];
        tree[root].cnt = 1;
        return;
    }

    int mid = (left + right) / 2;
    build_tree(root * 2, left, mid);
    build_tree(root * 2 + 1, mid + 1, right);

    tree[root] = merge_node(tree[root * 2], tree[root * 2 + 1]);
}

void update_range(int root, int left, int right, int qleft, int qright, int val)
{
    push_lazy(root, left, right);
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        lazy[root] = val;
        push_lazy(root, left, right);
        return;
    }

    int mid = (left + right) / 2;
    update_range(root * 2, left, mid, qleft, qright, val);
    update_range(root * 2 + 1, mid + 1, right, qleft, qright, val);

    tree[root] = merge_node(tree[root * 2], tree[root * 2 + 1]);
}
node query(int root, int left, int right, int qleft, int qright)
{
    push_lazy(root, left, right);
    if (left > qright || right < qleft)
        return node(-1, 1e9 + 10);

    if (left >= qleft && right <= qright)
        return tree[root];

    int mid = (left + right) / 2;

    return merge_node(query(root * 2, left, mid, qleft, qright),
            query(root * 2 + 1, mid + 1, right, qleft, qright));
}

ll values[maxn];

struct segment_tree
{
    ll tree[4 * maxn], lazy[4 * maxn];


    void build_tree(int root, int left, int right)
    {
        lazy[root] = 0;
        if (left == right)
        {
            tree[root] = values[left];
            return;
        }

        int mid = (left + right) / 2;
        build_tree(root * 2, left, mid);
        build_tree(root * 2 + 1, mid + 1, right);

        tree[root] = max(tree[root * 2], tree[root * 2 + 1]);
    }

    void push_lazy(int root, int left, int right)
    {
        tree[root] += lazy[root];
        if (left != right)
        {
            lazy[root * 2] += lazy[root];
            lazy[root * 2 + 1] += lazy[root];
        }

        lazy[root] = 0;
    }

    void update_range(int root, int left, int right, int qleft, int qright, ll val)
    {
        push_lazy(root, left, right);
        if (left > qright || right < qleft)
            return;

        if (left >= qleft && right <= qright)
        {
            lazy[root] += val;
            push_lazy(root, left, right);
            return;
        }

        int mid = (left + right) / 2;
        update_range(root * 2, left, mid, qleft, qright, val);
        update_range(root * 2 + 1, mid + 1, right, qleft, qright, val);

        tree[root] = max(tree[root * 2], tree[root * 2 + 1]);
    }

    ll walk_left(int root, int left, int right, int qleft, int qright, ll val)
    {
        push_lazy(root, left, right);
        if (left > qright || right < qleft || tree[root] <= val)
            return n + 1;

        if (left == right)
            return left;

        int mid = (left + right) / 2;
        if (left >= qleft && right <= qright)
        {
            push_lazy(root * 2, left, mid);
            push_lazy(root * 2 + 1, mid + 1, right);
            if (tree[root * 2] > val)
                return walk_left(root * 2, left, mid, qleft, qright, val);
            return walk_left(root * 2 + 1, mid + 1, right, qleft, qright, val);
        }

        return min(walk_left(root * 2, left, mid, qleft, qright, val),
                walk_left(root * 2 + 1, mid + 1, right, qleft, qright, val));
    }

    ll walk_right(int root, int left, int right, int qleft, int qright, ll val)
    {
        push_lazy(root, left, right);
        if (left > qright || right < qleft || tree[root] <= val)
            return 0;

        if (left == right)
            return left;

        int mid = (left + right) / 2;
        if (left >= qleft && right <= qright)
        {
            push_lazy(root * 2, left, mid);
            push_lazy(root * 2 + 1, mid + 1, right);
            if (tree[root * 2 + 1] > val)
                    return walk_right(root * 2 + 1, mid + 1, right, qleft, qright, val);
            return walk_right(root * 2, left, mid, qleft, qright, val);
        }

        return max(walk_right(root * 2, left, mid, qleft, qright, val),
                walk_right(root * 2 + 1, mid + 1, right, qleft, qright, val));
    }
};

segment_tree left_tree, right_tree;

ll fen[maxn];

void update_fen(int pos, ll val)
{
    for (int i = pos; i <= n; i += (i & -i))
        fen[i] += val;
}

ll query_fen(int pos)
{
    ll s = 0;
    for (int i = pos; i > 0; i -= (i & -i))
        s += fen[i];
    return s;
}

ll range_sum(int left, int right)
{
    return query_fen(right) - query_fen(left - 1);
}

void solve_query(int left, int right)
{
    int lb = left_tree.walk_right(1, 1, n, left, right, - query_fen(left - 1));
    int rb = right_tree.walk_left(1, 1, n, left, right, query_fen(right));


    cout << query(1, 1, n, lb, rb).cnt << endl;
}

void restructure()
{
    ///cout << "-------------" << endl;

    build_tree(1, 1, n);
    for (interval cur : ranges)
    {
        ll mx = min(a[cur.left], a[cur.right]);
        if (range_sum(cur.left + 1, cur.right - 1) < mx)
        {
            update_range(1, 1, n, cur.left + 1, cur.right - 1, 1);
            ///cout << cur.left << " " << cur.right << endl;
            //for (int i = cur.left + 1; i < cur.right; i ++)
              //  b[i] ++;
        }
    }
}


    vector < interval > to_add;
        vector < pair < int, int > > to_fix;
void fix_point(int pos)
{

    to_fix.clear();
    int root = 1, left = 0, right = n + 1;
    vector < interval > to_rem;
    while(true)
    {
        for (interval cur : act[root])
        {
            to_rem.push_back(cur);
            if (cur.pivot == cur.left)
                to_fix.push_back({cur.pivot, 0});
            else
                to_fix.push_back({cur.pivot, 1});
        }
        if (left == right)
            break;
        int mid = (left + right) / 2;
        if (pos <= mid)
            right = mid, root *= 2;
        else
            left = mid + 1, root = (root * 2) + 1;
    }
    for (interval cur : pact[pos])
    {
        to_rem.push_back(cur);
        if (cur.pivot == cur.left)
            to_fix.push_back({cur.pivot, 0});
        else
            to_fix.push_back({cur.pivot, 1});
    }
    ///sort(to_rem.begin(), to_rem.end(), cmp_interval);
    reverse(to_rem.begin(), to_rem.end());
    for (interval cur : to_rem)
    {
        //cout << "remove " << cur.left << " " << cur.right << endl;
       // if (ranges.find(cur) == ranges.end())
          //  cout << "yep" << endl;
        pact[cur.left].erase(cur);
        pact[cur.right].erase(cur);
        if (range_sum(cur.left + 1, cur.right - 1) < min(a[cur.left], a[cur.right]))
            update_range(1, 1, n, cur.left + 1, cur.right - 1, -1);
        rem_range(1, 0, n + 1, cur.left + 1, cur.right -1);
    }





}

void addition()
{

    to_add.clear();
    for (pair < int, int > cur : to_fix)
    {
        if (cur.second == 0)
        {
            int df = cur.first + 1;
            while(a[df] < a[cur.first])
                df ++;
            to_add.push_back(interval(cur.first, df, cur.first));
        }
        else
        {
            int df = cur.first - 1;
            while(a[df] < a[cur.first])
                df --;
            to_add.push_back(interval(df, cur.first, cur.first));
        }
    }
    sort(to_add.begin(), to_add.end(), cmp_interval);
    ///reverse(to_add.begin(), to_add.end());
    for (interval cur : to_add)
    {
        pact[cur.left].insert(cur);
        pact[cur.right].insert(cur);
        if (range_sum(cur.left + 1, cur.right - 1) < min(a[cur.left], a[cur.right]))
            update_range(1, 1, n, cur.left + 1, cur.right - 1, 1);
        ///cout << "added " << cur.left << " : " << cur.right << endl;
        add_range(1, 0, n + 1, cur.left + 1, cur.right - 1, cur);
    }
}
void simulate()
{

    for (int i = 1; i <= n; i ++)
        update_fen(i, a[i]);
    get_ranges();

    restructure();

    for (int i = 1; i <= n; i ++)
    {
        values[i] = a[i] - query_fen(i - 1);
    }
    left_tree.build_tree(1, 1, n);

    for (int i = 1; i <= n; i ++)
    {
        values[i] = a[i] + query_fen(i);
    }
    right_tree.build_tree(1, 1, n);
    for (int i = 1; i <= q; i ++)
    {
        int type;
        cin >> type;
        if (type == 1)
        {
            int idx;
            ll x;
            cin >> idx >> x;
            fix_point(idx);
            update_fen(idx, x - a[idx]);
            left_tree.update_range(1, 1, n, idx + 1, n, - (x - a[idx]));
            left_tree.update_range(1, 1, n, idx, idx, (x - a[idx]));
            right_tree.update_range(1, 1, n, idx, n, (x - a[idx]));
            right_tree.update_range(1, 1, n, idx, idx, (x - a[idx]));
            a[idx] = x;
            addition();
        }
        else
        {
            int l, r;
            cin >> l >> r;
            solve_query(l, r);
        }
    }
}
void solve()
{
    input();
    simulate();
}

void speed()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}
int main()
{
    ///freopen("test.txt", "r", stdin);
    speed();
    solve();
    return 0;
}
/*
12
32 32 4 1 1 1 1 4 4 16 32 128
1
2 8 10


*/

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29272 KB Output is correct
2 Correct 5 ms 29276 KB Output is correct
3 Correct 5 ms 29368 KB Output is correct
4 Correct 6 ms 29372 KB Output is correct
5 Correct 12 ms 29644 KB Output is correct
6 Correct 7 ms 29528 KB Output is correct
7 Correct 11 ms 29528 KB Output is correct
8 Correct 9 ms 29532 KB Output is correct
9 Correct 7 ms 29532 KB Output is correct
10 Correct 9 ms 29528 KB Output is correct
11 Correct 6 ms 29720 KB Output is correct
12 Correct 9 ms 29532 KB Output is correct
13 Correct 9 ms 29696 KB Output is correct
14 Correct 8 ms 29696 KB Output is correct
15 Correct 9 ms 29532 KB Output is correct
16 Correct 7 ms 29532 KB Output is correct
17 Correct 10 ms 29532 KB Output is correct
18 Correct 7 ms 29528 KB Output is correct
19 Correct 8 ms 29636 KB Output is correct
20 Correct 7 ms 29532 KB Output is correct

Subtask #2
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29276 KB Output is correct
2 Correct 226 ms 79332 KB Output is correct
3 Correct 213 ms 78452 KB Output is correct
4 Correct 211 ms 79392 KB Output is correct
5 Correct 202 ms 78128 KB Output is correct
6 Correct 195 ms 77028 KB Output is correct
7 Correct 192 ms 75716 KB Output is correct
8 Correct 191 ms 76740 KB Output is correct
9 Correct 214 ms 76036 KB Output is correct
10 Correct 201 ms 79044 KB Output is correct
11 Correct 194 ms 76000 KB Output is correct
12 Correct 188 ms 75972 KB Output is correct
13 Correct 188 ms 76040 KB Output is correct
14 Correct 180 ms 75964 KB Output is correct
15 Correct 188 ms 76080 KB Output is correct

Subtask #3
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29272 KB Output is correct
2 Correct 5 ms 29276 KB Output is correct
3 Correct 5 ms 29368 KB Output is correct
4 Correct 6 ms 29372 KB Output is correct
5 Correct 12 ms 29644 KB Output is correct
6 Correct 7 ms 29528 KB Output is correct
7 Correct 11 ms 29528 KB Output is correct
8 Correct 9 ms 29532 KB Output is correct
9 Correct 7 ms 29532 KB Output is correct
10 Correct 9 ms 29528 KB Output is correct
11 Correct 6 ms 29720 KB Output is correct
12 Correct 9 ms 29532 KB Output is correct
13 Correct 9 ms 29696 KB Output is correct
14 Correct 8 ms 29696 KB Output is correct
15 Correct 9 ms 29532 KB Output is correct
16 Correct 7 ms 29532 KB Output is correct
17 Correct 10 ms 29532 KB Output is correct
18 Correct 7 ms 29528 KB Output is correct
19 Correct 8 ms 29636 KB Output is correct
20 Correct 7 ms 29532 KB Output is correct
21 Correct 5 ms 29276 KB Output is correct
22 Correct 226 ms 79332 KB Output is correct
23 Correct 213 ms 78452 KB Output is correct
24 Correct 211 ms 79392 KB Output is correct
25 Correct 202 ms 78128 KB Output is correct
26 Correct 195 ms 77028 KB Output is correct
27 Correct 192 ms 75716 KB Output is correct
28 Correct 191 ms 76740 KB Output is correct
29 Correct 214 ms 76036 KB Output is correct
30 Correct 201 ms 79044 KB Output is correct
31 Correct 194 ms 76000 KB Output is correct
32 Correct 188 ms 75972 KB Output is correct
33 Correct 188 ms 76040 KB Output is correct
34 Correct 180 ms 75964 KB Output is correct
35 Correct 188 ms 76080 KB Output is correct
36 Correct 253 ms 79252 KB Output is correct
37 Correct 222 ms 78336 KB Output is correct
38 Correct 202 ms 78532 KB Output is correct
39 Correct 283 ms 79516 KB Output is correct
40 Correct 203 ms 78260 KB Output is correct
41 Correct 222 ms 76696 KB Output is correct
42 Correct 207 ms 76632 KB Output is correct
43 Correct 217 ms 75968 KB Output is correct
44 Correct 196 ms 75800 KB Output is correct
45 Correct 245 ms 78856 KB Output is correct
46 Correct 209 ms 79052 KB Output is correct
47 Correct 178 ms 76156 KB Output is correct
48 Correct 252 ms 76228 KB Output is correct
49 Correct 191 ms 76072 KB Output is correct
50 Correct 186 ms 75768 KB Output is correct
51 Correct 194 ms 75952 KB Output is correct
52 Correct 180 ms 75972 KB Output is correct

Subtask #4
23.0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29276 KB Output is correct
2 Correct 226 ms 79332 KB Output is correct
3 Correct 213 ms 78452 KB Output is correct
4 Correct 211 ms 79392 KB Output is correct
5 Correct 202 ms 78128 KB Output is correct
6 Correct 195 ms 77028 KB Output is correct
7 Correct 192 ms 75716 KB Output is correct
8 Correct 191 ms 76740 KB Output is correct
9 Correct 214 ms 76036 KB Output is correct
10 Correct 201 ms 79044 KB Output is correct
11 Correct 194 ms 76000 KB Output is correct
12 Correct 188 ms 75972 KB Output is correct
13 Correct 188 ms 76040 KB Output is correct
14 Correct 180 ms 75964 KB Output is correct
15 Correct 188 ms 76080 KB Output is correct
16 Correct 5 ms 29276 KB Output is correct
17 Correct 355 ms 78492 KB Output is correct
18 Correct 355 ms 79552 KB Output is correct
19 Correct 356 ms 78640 KB Output is correct
20 Correct 354 ms 78372 KB Output is correct
21 Correct 349 ms 78496 KB Output is correct
22 Correct 348 ms 79808 KB Output is correct
23 Correct 348 ms 78280 KB Output is correct
24 Correct 378 ms 78676 KB Output is correct
25 Correct 362 ms 78400 KB Output is correct
26 Correct 376 ms 78780 KB Output is correct
27 Correct 333 ms 77220 KB Output is correct
28 Correct 336 ms 77460 KB Output is correct
29 Correct 326 ms 77252 KB Output is correct
30 Correct 346 ms 76352 KB Output is correct
31 Correct 347 ms 76044 KB Output is correct
32 Correct 371 ms 76360 KB Output is correct
33 Correct 354 ms 79512 KB Output is correct
34 Correct 366 ms 76304 KB Output is correct
35 Correct 337 ms 75968 KB Output is correct
36 Correct 360 ms 79044 KB Output is correct
37 Correct 309 ms 76196 KB Output is correct
38 Correct 318 ms 76316 KB Output is correct
39 Correct 313 ms 76476 KB Output is correct
40 Correct 338 ms 76732 KB Output is correct

Subtask #5
0 / 35.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29276 KB Output is correct
2 Correct 226 ms 79332 KB Output is correct
3 Correct 213 ms 78452 KB Output is correct
4 Correct 211 ms 79392 KB Output is correct
5 Correct 202 ms 78128 KB Output is correct
6 Correct 195 ms 77028 KB Output is correct
7 Correct 192 ms 75716 KB Output is correct
8 Correct 191 ms 76740 KB Output is correct
9 Correct 214 ms 76036 KB Output is correct
10 Correct 201 ms 79044 KB Output is correct
11 Correct 194 ms 76000 KB Output is correct
12 Correct 188 ms 75972 KB Output is correct
13 Correct 188 ms 76040 KB Output is correct
14 Correct 180 ms 75964 KB Output is correct
15 Correct 188 ms 76080 KB Output is correct
16 Correct 5 ms 29272 KB Output is correct
17 Correct 2840 ms 83944 KB Output is correct
18 Correct 3879 ms 86632 KB Output is correct
19 Correct 1995 ms 80448 KB Output is correct
20 Correct 2954 ms 87556 KB Output is correct
21 Correct 2700 ms 86148 KB Output is correct
22 Correct 3690 ms 88948 KB Output is correct
23 Correct 2278 ms 80516 KB Output is correct
24 Correct 3435 ms 88264 KB Output is correct
25 Correct 2126 ms 80496 KB Output is correct
26 Execution timed out 4048 ms 81384 KB Time limit exceeded
27 Halted 0 ms 0 KB -

Subtask #6
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 29272 KB Output is correct
2 Correct 5 ms 29276 KB Output is correct
3 Correct 5 ms 29368 KB Output is correct
4 Correct 6 ms 29372 KB Output is correct
5 Correct 12 ms 29644 KB Output is correct
6 Correct 7 ms 29528 KB Output is correct
7 Correct 11 ms 29528 KB Output is correct
8 Correct 9 ms 29532 KB Output is correct
9 Correct 7 ms 29532 KB Output is correct
10 Correct 9 ms 29528 KB Output is correct
11 Correct 6 ms 29720 KB Output is correct
12 Correct 9 ms 29532 KB Output is correct
13 Correct 9 ms 29696 KB Output is correct
14 Correct 8 ms 29696 KB Output is correct
15 Correct 9 ms 29532 KB Output is correct
16 Correct 7 ms 29532 KB Output is correct
17 Correct 10 ms 29532 KB Output is correct
18 Correct 7 ms 29528 KB Output is correct
19 Correct 8 ms 29636 KB Output is correct
20 Correct 7 ms 29532 KB Output is correct
21 Correct 5 ms 29276 KB Output is correct
22 Correct 226 ms 79332 KB Output is correct
23 Correct 213 ms 78452 KB Output is correct
24 Correct 211 ms 79392 KB Output is correct
25 Correct 202 ms 78128 KB Output is correct
26 Correct 195 ms 77028 KB Output is correct
27 Correct 192 ms 75716 KB Output is correct
28 Correct 191 ms 76740 KB Output is correct
29 Correct 214 ms 76036 KB Output is correct
30 Correct 201 ms 79044 KB Output is correct
31 Correct 194 ms 76000 KB Output is correct
32 Correct 188 ms 75972 KB Output is correct
33 Correct 188 ms 76040 KB Output is correct
34 Correct 180 ms 75964 KB Output is correct
35 Correct 188 ms 76080 KB Output is correct
36 Correct 253 ms 79252 KB Output is correct
37 Correct 222 ms 78336 KB Output is correct
38 Correct 202 ms 78532 KB Output is correct
39 Correct 283 ms 79516 KB Output is correct
40 Correct 203 ms 78260 KB Output is correct
41 Correct 222 ms 76696 KB Output is correct
42 Correct 207 ms 76632 KB Output is correct
43 Correct 217 ms 75968 KB Output is correct
44 Correct 196 ms 75800 KB Output is correct
45 Correct 245 ms 78856 KB Output is correct
46 Correct 209 ms 79052 KB Output is correct
47 Correct 178 ms 76156 KB Output is correct
48 Correct 252 ms 76228 KB Output is correct
49 Correct 191 ms 76072 KB Output is correct
50 Correct 186 ms 75768 KB Output is correct
51 Correct 194 ms 75952 KB Output is correct
52 Correct 180 ms 75972 KB Output is correct
53 Correct 5 ms 29276 KB Output is correct
54 Correct 355 ms 78492 KB Output is correct
55 Correct 355 ms 79552 KB Output is correct
56 Correct 356 ms 78640 KB Output is correct
57 Correct 354 ms 78372 KB Output is correct
58 Correct 349 ms 78496 KB Output is correct
59 Correct 348 ms 79808 KB Output is correct
60 Correct 348 ms 78280 KB Output is correct
61 Correct 378 ms 78676 KB Output is correct
62 Correct 362 ms 78400 KB Output is correct
63 Correct 376 ms 78780 KB Output is correct
64 Correct 333 ms 77220 KB Output is correct
65 Correct 336 ms 77460 KB Output is correct
66 Correct 326 ms 77252 KB Output is correct
67 Correct 346 ms 76352 KB Output is correct
68 Correct 347 ms 76044 KB Output is correct
69 Correct 371 ms 76360 KB Output is correct
70 Correct 354 ms 79512 KB Output is correct
71 Correct 366 ms 76304 KB Output is correct
72 Correct 337 ms 75968 KB Output is correct
73 Correct 360 ms 79044 KB Output is correct
74 Correct 309 ms 76196 KB Output is correct
75 Correct 318 ms 76316 KB Output is correct
76 Correct 313 ms 76476 KB Output is correct
77 Correct 338 ms 76732 KB Output is correct
78 Correct 5 ms 29272 KB Output is correct
79 Correct 2840 ms 83944 KB Output is correct
80 Correct 3879 ms 86632 KB Output is correct
81 Correct 1995 ms 80448 KB Output is correct
82 Correct 2954 ms 87556 KB Output is correct
83 Correct 2700 ms 86148 KB Output is correct
84 Correct 3690 ms 88948 KB Output is correct
85 Correct 2278 ms 80516 KB Output is correct
86 Correct 3435 ms 88264 KB Output is correct
87 Correct 2126 ms 80496 KB Output is correct
88 Execution timed out 4048 ms 81384 KB Time limit exceeded
89 Halted 0 ms 0 KB -