oj.uz

Submission #797256

# Submission time Handle Problem Language Result Execution time Memory
797256 2023-07-29T08:35:32 Z eltu0815 Fish 2 (JOI22_fish2) C++14
100 / 100
 2100 ms 25100 KB 
#include <bits/stdc++.h>
#define MAX 500005
#define MOD (ll)(1e9+7)
#define INF (ll)(1e18)
#define inf (1000000001)
 
using namespace std;    
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
 
int n, q;
int arr[100005];
 
struct SEG1 {
    ll seg[400005];
    void update(int str, int ed, int idx, ll val, int node) {
        if(str == ed) {
            seg[node] = val;
            return;
        }
        int mid = str + ed >> 1;
        if(idx <= mid) update(str, mid, idx, val, node << 1);
        else update(mid + 1, ed, idx, val, node << 1 | 1);
        seg[node] = seg[node << 1] + seg[node << 1 | 1];
    }
    ll query(int str, int ed, int left, int right, int node) {
        if(str > right || ed < left) return 0;
        if(left <= str && ed <= right) return seg[node];
        int mid = str + ed >> 1;
        return query(str, mid, left, right, node << 1) + query(mid + 1, ed, left, right, node << 1 | 1);
    }
} seg1;
 
struct SEG2 {
    int seg[400005];
    void update(int str, int ed, int idx, int val, int node) {
        if(str == ed) {
            seg[node] = val;
            return;
        }
        int mid = str + ed >> 1;
        if(idx <= mid) update(str, mid, idx, val, node << 1);
        else update(mid + 1, ed, idx, val, node << 1 | 1);
        seg[node] = max(seg[node << 1], seg[node << 1 | 1]);
    }
    int get_mx(int str, int ed, int left, int right, int val, int node) {
        if(str > right || ed < left) return -1;
        if(seg[node] <= val) return -1;
        if(str == ed) return str;
        int mid = str + ed >> 1;
        int tmp = get_mx(mid + 1, ed, left, right, val, node << 1 | 1);
        if(tmp != -1) return tmp;
        return get_mx(str, mid, left, right, val, node << 1);
    }
    int get_mn(int str, int ed, int left, int right, ll val, int node) {
        if(str > right || ed < left) return -1;
        if(seg[node] <= val) return -1;
        if(str == ed) return str;
        int mid = str + ed >> 1;
        int tmp = get_mn(str, mid, left, right, val, node << 1);
        if(tmp != -1) return tmp;
        return get_mn(mid + 1, ed, left, right, val, node << 1 | 1);
    }
} seg2;
 
struct SEG3 {
    struct Node{
        int mn, cnt;
        Node() { mn = inf, cnt = 0; }
    };
    Node seg[400005];
    int lazy[400005];
    Node Merge(Node l, Node r) {
        Node ret; ret.cnt = 0;
        ret.mn = min(l.mn, r.mn);
        if(l.mn == ret.mn) ret.cnt += l.cnt;
        if(r.mn == ret.mn) ret.cnt += r.cnt;
        return ret;
    }
    void init(int str, int ed, int node) {
        lazy[node] = 0;
        if(str == ed) {
            seg[node].mn = 0, seg[node].cnt = 1;
            return;
        }
        int mid = str + ed >> 1;
        init(str, mid, node << 1);
        init(mid + 1, ed, node << 1 | 1);
        seg[node] = Merge(seg[node << 1], seg[node << 1 | 1]);
    }
    void lazyProp(int str, int ed, int node) {
        if(lazy[node]) {
            seg[node].mn += lazy[node];
            if(str != ed) {
                lazy[node << 1] += lazy[node];
                lazy[node << 1 | 1] += lazy[node];
            }
            lazy[node] = 0;
        }
    }
    void update(int str, int ed, int left, int right, int val, int node) {
        lazyProp(str, ed, node);
        if(str > right || ed < left) return;
        if(left <= str && ed <= right) {
            lazy[node] += val;
            lazyProp(str, ed, node);
            return;
        }
        int mid = str + ed >> 1;
        update(str, mid, left, right, val, node << 1);
        update(mid + 1, ed, left, right, val, node << 1 | 1);
        seg[node] = Merge(seg[node << 1], seg[node << 1 | 1]);
    }
    Node query(int str, int ed, int left, int right, int node) {
        lazyProp(str, ed, node);
        if(str > right || ed < left) return Node();
        if(left <= str && ed <= right) return seg[node];
        int mid = str + ed >> 1;
        return Merge(query(str, mid, left, right, node << 1), query(mid + 1, ed, left, right, node << 1 | 1));
    }
} seg3;
 
set<pii> s;
struct SEG4 {
    vector<pii> seg[400005];
    void update(int str, int ed, int l, int r, int node) {
        int mid = str + ed >> 1;
        if(str == ed || (l <= mid && r > mid)) {
            assert(seg[node].empty() || (l <= seg[node].back().first && r >= seg[node].back().second));
            seg[node].push_back({l, r});
            seg3.update(1, n, l, r, 1, 1);
            return;
        }
        if(r <= mid) update(str, mid, l, r, node << 1);
        else update(mid + 1, ed, l, r, node << 1 | 1);
    }
    
    void erasex(int str, int ed, int x, int node) {
        while(!seg[node].empty() && seg[node].back().first <= x && x <= seg[node].back().second) {
            seg3.update(1, n, seg[node].back().first, seg[node].back().second, -1, 1);
            s.erase({seg[node].back().first, seg[node].back().second});
            seg[node].pop_back();
        }
        if(str == ed) return;
        int mid = str + ed >> 1;
        if(x <= mid) erasex(str, mid, x, node << 1);
        else erasex(mid + 1, ed, x, node << 1 | 1);
    }
} seg4;

vector<pii> range;
void update(int i) {
    vector<pll> left, right;
    int j = i, sum = arr[j];
    while(j > 1) {
        j = seg2.get_mx(1, n, 1, j - 1, sum, 1);
        if(j == -1) break;
        left.push_back({j, seg1.query(1, n, 1, j, 1)});
        sum += arr[j];
    }
    left.push_back({0, 0});
    
    j = i, sum = arr[j];
    while(j < n) {
        j = seg2.get_mn(1, n, j + 1, n, sum, 1);
        if(j == -1) break;
        right.push_back({j, seg1.query(1, n, 1, j - 1, 1)});
        sum += arr[j];
    }
    right.push_back({n + 1, seg1.query(1, n, 1, n, 1)});
    
    for(auto l : left) for(auto r : right) {
        if(l.first == 0 && r.first == n + 1) continue;
        if(r.second - l.second < (ll)min(arr[r.first], arr[l.first])) {
            range.push_back({l.first + 1, r.first - 1});
        }
    }
}

void update_range() {
    sort(range.begin(), range.end(), [&](auto a, auto b) {
            if(a.second - a.first != b.second - b.first) return a.second - a.first < b.second - b.first;
            return a.first < b.first;
        });
    
    for(auto [l, r] : range) {
        if(s.find({l, r}) == s.end()) {
            seg4.update(1, n, l, r, 1);
            s.insert({l, r});
        }
    }
    range.clear();
}
 
int compL(int i, int lim) {
    vector<int> right;
    int j = i, sum = arr[j];
    while(j < n) {
        j = seg2.get_mn(1, n, j + 1, n, sum, 1);
        if(j == -1) break;
        right.push_back(j);
        sum += arr[j];
    }
    int mx = i;
    for(auto r : right) {
        if(r <= lim && seg1.query(1, n, i, r - 1, 1) < (ll)arr[r]) mx = max(mx, r);
    }
    return mx;
}
 
int compR(int i, int lim) {
    vector<int> left;
    int j = i, sum = arr[j];
    while(j > 1) {
        j = seg2.get_mx(1, n, 1, j - 1, sum, 1);
        if(j == -1) break;
        left.push_back(j);
        sum += arr[j];
    }
    int mn = i;
    for(auto l : left) {
        if(l >= lim && seg1.query(1, n, l + 1, i, 1) < (ll)arr[l]) mn = min(mn, l);
    }
    return mn;
}
 
void update_query(int a, int b) {
    arr[a] = b;
    seg1.update(1, n, a, b, 1);
    seg2.update(1, n, a, b, 1);
    
    seg4.erasex(1, n, a, 1);
    if(a > 1) seg4.erasex(1, n, a - 1, 1);
    if(a < n) seg4.erasex(1, n, a + 1, 1);
    
    update(a);
    if(a > 1) update(a - 1);
    if(a < n) update(a + 1);
    update_range();
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    
    cin >> n;
    seg3.init(1, n, 1); arr[0] = arr[n + 1] = inf;
    for(int i = 1; i <= n; ++i) {
        cin >> arr[i];
        update_query(i, arr[i]);
    }
    
    cin >> q;
    while(q--) {
        int t, a, b; cin >> t >> a >> b;
        if(t == 1) update_query(a, b);
        else {
            int l = a, r = b;
            a = compL(a, r); b = compR(b, l);
            cout << seg3.query(1, n, a, b, 1).cnt << '\n';
        }
    }
    return 0;
}

Compilation message

fish2.cpp: In member function 'void SEG1::update(int, int, int, ll, int)':
fish2.cpp:22:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   22 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'll SEG1::query(int, int, int, int, int)':
fish2.cpp:30:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   30 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'void SEG2::update(int, int, int, int, int)':
fish2.cpp:42:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   42 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'int SEG2::get_mx(int, int, int, int, int, int)':
fish2.cpp:51:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   51 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'int SEG2::get_mn(int, int, int, int, ll, int)':
fish2.cpp:60:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   60 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'void SEG3::init(int, int, int)':
fish2.cpp:87:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
   87 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'void SEG3::update(int, int, int, int, int, int)':
fish2.cpp:110:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
  110 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'SEG3::Node SEG3::query(int, int, int, int, int)':
fish2.cpp:119:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
  119 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'void SEG4::update(int, int, int, int, int)':
fish2.cpp:128:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
  128 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In member function 'void SEG4::erasex(int, int, int, int)':
fish2.cpp:146:23: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
  146 |         int mid = str + ed >> 1;
      |                   ~~~~^~~~
fish2.cpp: In function 'void update_range()':
fish2.cpp:187:14: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
  187 |     for(auto [l, r] : range) {
      |              ^

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 12756 KB Output is correct
2 Correct 6 ms 12756 KB Output is correct
3 Correct 6 ms 12756 KB Output is correct
4 Correct 6 ms 12756 KB Output is correct
5 Correct 12 ms 12884 KB Output is correct
6 Correct 8 ms 12864 KB Output is correct
7 Correct 12 ms 12884 KB Output is correct
8 Correct 10 ms 12884 KB Output is correct
9 Correct 9 ms 12884 KB Output is correct
10 Correct 10 ms 12920 KB Output is correct
11 Correct 9 ms 12884 KB Output is correct
12 Correct 11 ms 12924 KB Output is correct
13 Correct 9 ms 12896 KB Output is correct
14 Correct 11 ms 12888 KB Output is correct
15 Correct 11 ms 12920 KB Output is correct
16 Correct 11 ms 12884 KB Output is correct
17 Correct 9 ms 12884 KB Output is correct
18 Correct 8 ms 12896 KB Output is correct
19 Correct 9 ms 12884 KB Output is correct
20 Correct 8 ms 12812 KB Output is correct

Subtask #2
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 12756 KB Output is correct
2 Correct 369 ms 22560 KB Output is correct
3 Correct 592 ms 22272 KB Output is correct
4 Correct 419 ms 22636 KB Output is correct
5 Correct 580 ms 22284 KB Output is correct
6 Correct 299 ms 20696 KB Output is correct
7 Correct 732 ms 19284 KB Output is correct
8 Correct 307 ms 20640 KB Output is correct
9 Correct 726 ms 19392 KB Output is correct
10 Correct 1087 ms 19788 KB Output is correct
11 Correct 1245 ms 19972 KB Output is correct
12 Correct 426 ms 20340 KB Output is correct
13 Correct 413 ms 20300 KB Output is correct
14 Correct 380 ms 22476 KB Output is correct
15 Correct 394 ms 22264 KB Output is correct

Subtask #3
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 12756 KB Output is correct
2 Correct 6 ms 12756 KB Output is correct
3 Correct 6 ms 12756 KB Output is correct
4 Correct 6 ms 12756 KB Output is correct
5 Correct 12 ms 12884 KB Output is correct
6 Correct 8 ms 12864 KB Output is correct
7 Correct 12 ms 12884 KB Output is correct
8 Correct 10 ms 12884 KB Output is correct
9 Correct 9 ms 12884 KB Output is correct
10 Correct 10 ms 12920 KB Output is correct
11 Correct 9 ms 12884 KB Output is correct
12 Correct 11 ms 12924 KB Output is correct
13 Correct 9 ms 12896 KB Output is correct
14 Correct 11 ms 12888 KB Output is correct
15 Correct 11 ms 12920 KB Output is correct
16 Correct 11 ms 12884 KB Output is correct
17 Correct 9 ms 12884 KB Output is correct
18 Correct 8 ms 12896 KB Output is correct
19 Correct 9 ms 12884 KB Output is correct
20 Correct 8 ms 12812 KB Output is correct
21 Correct 5 ms 12756 KB Output is correct
22 Correct 369 ms 22560 KB Output is correct
23 Correct 592 ms 22272 KB Output is correct
24 Correct 419 ms 22636 KB Output is correct
25 Correct 580 ms 22284 KB Output is correct
26 Correct 299 ms 20696 KB Output is correct
27 Correct 732 ms 19284 KB Output is correct
28 Correct 307 ms 20640 KB Output is correct
29 Correct 726 ms 19392 KB Output is correct
30 Correct 1087 ms 19788 KB Output is correct
31 Correct 1245 ms 19972 KB Output is correct
32 Correct 426 ms 20340 KB Output is correct
33 Correct 413 ms 20300 KB Output is correct
34 Correct 380 ms 22476 KB Output is correct
35 Correct 394 ms 22264 KB Output is correct
36 Correct 342 ms 23148 KB Output is correct
37 Correct 604 ms 22500 KB Output is correct
38 Correct 603 ms 21756 KB Output is correct
39 Correct 375 ms 23244 KB Output is correct
40 Correct 614 ms 21816 KB Output is correct
41 Correct 301 ms 20756 KB Output is correct
42 Correct 325 ms 20652 KB Output is correct
43 Correct 763 ms 19376 KB Output is correct
44 Correct 659 ms 19228 KB Output is correct
45 Correct 1131 ms 20296 KB Output is correct
46 Correct 1100 ms 19916 KB Output is correct
47 Correct 1207 ms 18628 KB Output is correct
48 Correct 420 ms 20464 KB Output is correct
49 Correct 379 ms 20276 KB Output is correct
50 Correct 394 ms 22692 KB Output is correct
51 Correct 392 ms 22348 KB Output is correct
52 Correct 392 ms 22520 KB Output is correct

Subtask #4
23.0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 12756 KB Output is correct
2 Correct 369 ms 22560 KB Output is correct
3 Correct 592 ms 22272 KB Output is correct
4 Correct 419 ms 22636 KB Output is correct
5 Correct 580 ms 22284 KB Output is correct
6 Correct 299 ms 20696 KB Output is correct
7 Correct 732 ms 19284 KB Output is correct
8 Correct 307 ms 20640 KB Output is correct
9 Correct 726 ms 19392 KB Output is correct
10 Correct 1087 ms 19788 KB Output is correct
11 Correct 1245 ms 19972 KB Output is correct
12 Correct 426 ms 20340 KB Output is correct
13 Correct 413 ms 20300 KB Output is correct
14 Correct 380 ms 22476 KB Output is correct
15 Correct 394 ms 22264 KB Output is correct
16 Correct 6 ms 12828 KB Output is correct
17 Correct 1059 ms 22612 KB Output is correct
18 Correct 699 ms 23664 KB Output is correct
19 Correct 1037 ms 22968 KB Output is correct
20 Correct 1060 ms 22756 KB Output is correct
21 Correct 1028 ms 22672 KB Output is correct
22 Correct 698 ms 23648 KB Output is correct
23 Correct 973 ms 22452 KB Output is correct
24 Correct 1116 ms 23208 KB Output is correct
25 Correct 1014 ms 22964 KB Output is correct
26 Correct 1109 ms 23244 KB Output is correct
27 Correct 445 ms 21324 KB Output is correct
28 Correct 451 ms 21204 KB Output is correct
29 Correct 448 ms 21216 KB Output is correct
30 Correct 1255 ms 19512 KB Output is correct
31 Correct 1185 ms 19524 KB Output is correct
32 Correct 1888 ms 20376 KB Output is correct
33 Correct 1381 ms 20080 KB Output is correct
34 Correct 1992 ms 19648 KB Output is correct
35 Correct 1658 ms 19080 KB Output is correct
36 Correct 1669 ms 20376 KB Output is correct
37 Correct 619 ms 20616 KB Output is correct
38 Correct 570 ms 20544 KB Output is correct
39 Correct 580 ms 23112 KB Output is correct
40 Correct 581 ms 22852 KB Output is correct

Subtask #5
35.0 / 35.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 12756 KB Output is correct
2 Correct 369 ms 22560 KB Output is correct
3 Correct 592 ms 22272 KB Output is correct
4 Correct 419 ms 22636 KB Output is correct
5 Correct 580 ms 22284 KB Output is correct
6 Correct 299 ms 20696 KB Output is correct
7 Correct 732 ms 19284 KB Output is correct
8 Correct 307 ms 20640 KB Output is correct
9 Correct 726 ms 19392 KB Output is correct
10 Correct 1087 ms 19788 KB Output is correct
11 Correct 1245 ms 19972 KB Output is correct
12 Correct 426 ms 20340 KB Output is correct
13 Correct 413 ms 20300 KB Output is correct
14 Correct 380 ms 22476 KB Output is correct
15 Correct 394 ms 22264 KB Output is correct
16 Correct 6 ms 12756 KB Output is correct
17 Correct 2087 ms 22652 KB Output is correct
18 Correct 1609 ms 24920 KB Output is correct
19 Correct 1783 ms 22492 KB Output is correct
20 Correct 1323 ms 25020 KB Output is correct
21 Correct 1881 ms 22716 KB Output is correct
22 Correct 1473 ms 25008 KB Output is correct
23 Correct 1939 ms 22752 KB Output is correct
24 Correct 1405 ms 24880 KB Output is correct
25 Correct 1806 ms 22496 KB Output is correct
26 Correct 650 ms 21836 KB Output is correct
27 Correct 769 ms 21952 KB Output is correct
28 Correct 1254 ms 23216 KB Output is correct
29 Correct 690 ms 21784 KB Output is correct
30 Correct 779 ms 22080 KB Output is correct
31 Correct 1527 ms 23588 KB Output is correct
32 Correct 2076 ms 23972 KB Output is correct
33 Correct 1662 ms 19828 KB Output is correct
34 Correct 1979 ms 24376 KB Output is correct
35 Correct 1517 ms 19804 KB Output is correct
36 Correct 1993 ms 23656 KB Output is correct
37 Correct 1202 ms 22888 KB Output is correct
38 Correct 885 ms 22320 KB Output is correct
39 Correct 833 ms 23456 KB Output is correct
40 Correct 622 ms 23140 KB Output is correct

Subtask #6
17.0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 6 ms 12756 KB Output is correct
2 Correct 6 ms 12756 KB Output is correct
3 Correct 6 ms 12756 KB Output is correct
4 Correct 6 ms 12756 KB Output is correct
5 Correct 12 ms 12884 KB Output is correct
6 Correct 8 ms 12864 KB Output is correct
7 Correct 12 ms 12884 KB Output is correct
8 Correct 10 ms 12884 KB Output is correct
9 Correct 9 ms 12884 KB Output is correct
10 Correct 10 ms 12920 KB Output is correct
11 Correct 9 ms 12884 KB Output is correct
12 Correct 11 ms 12924 KB Output is correct
13 Correct 9 ms 12896 KB Output is correct
14 Correct 11 ms 12888 KB Output is correct
15 Correct 11 ms 12920 KB Output is correct
16 Correct 11 ms 12884 KB Output is correct
17 Correct 9 ms 12884 KB Output is correct
18 Correct 8 ms 12896 KB Output is correct
19 Correct 9 ms 12884 KB Output is correct
20 Correct 8 ms 12812 KB Output is correct
21 Correct 5 ms 12756 KB Output is correct
22 Correct 369 ms 22560 KB Output is correct
23 Correct 592 ms 22272 KB Output is correct
24 Correct 419 ms 22636 KB Output is correct
25 Correct 580 ms 22284 KB Output is correct
26 Correct 299 ms 20696 KB Output is correct
27 Correct 732 ms 19284 KB Output is correct
28 Correct 307 ms 20640 KB Output is correct
29 Correct 726 ms 19392 KB Output is correct
30 Correct 1087 ms 19788 KB Output is correct
31 Correct 1245 ms 19972 KB Output is correct
32 Correct 426 ms 20340 KB Output is correct
33 Correct 413 ms 20300 KB Output is correct
34 Correct 380 ms 22476 KB Output is correct
35 Correct 394 ms 22264 KB Output is correct
36 Correct 342 ms 23148 KB Output is correct
37 Correct 604 ms 22500 KB Output is correct
38 Correct 603 ms 21756 KB Output is correct
39 Correct 375 ms 23244 KB Output is correct
40 Correct 614 ms 21816 KB Output is correct
41 Correct 301 ms 20756 KB Output is correct
42 Correct 325 ms 20652 KB Output is correct
43 Correct 763 ms 19376 KB Output is correct
44 Correct 659 ms 19228 KB Output is correct
45 Correct 1131 ms 20296 KB Output is correct
46 Correct 1100 ms 19916 KB Output is correct
47 Correct 1207 ms 18628 KB Output is correct
48 Correct 420 ms 20464 KB Output is correct
49 Correct 379 ms 20276 KB Output is correct
50 Correct 394 ms 22692 KB Output is correct
51 Correct 392 ms 22348 KB Output is correct
52 Correct 392 ms 22520 KB Output is correct
53 Correct 6 ms 12828 KB Output is correct
54 Correct 1059 ms 22612 KB Output is correct
55 Correct 699 ms 23664 KB Output is correct
56 Correct 1037 ms 22968 KB Output is correct
57 Correct 1060 ms 22756 KB Output is correct
58 Correct 1028 ms 22672 KB Output is correct
59 Correct 698 ms 23648 KB Output is correct
60 Correct 973 ms 22452 KB Output is correct
61 Correct 1116 ms 23208 KB Output is correct
62 Correct 1014 ms 22964 KB Output is correct
63 Correct 1109 ms 23244 KB Output is correct
64 Correct 445 ms 21324 KB Output is correct
65 Correct 451 ms 21204 KB Output is correct
66 Correct 448 ms 21216 KB Output is correct
67 Correct 1255 ms 19512 KB Output is correct
68 Correct 1185 ms 19524 KB Output is correct
69 Correct 1888 ms 20376 KB Output is correct
70 Correct 1381 ms 20080 KB Output is correct
71 Correct 1992 ms 19648 KB Output is correct
72 Correct 1658 ms 19080 KB Output is correct
73 Correct 1669 ms 20376 KB Output is correct
74 Correct 619 ms 20616 KB Output is correct
75 Correct 570 ms 20544 KB Output is correct
76 Correct 580 ms 23112 KB Output is correct
77 Correct 581 ms 22852 KB Output is correct
78 Correct 6 ms 12756 KB Output is correct
79 Correct 2087 ms 22652 KB Output is correct
80 Correct 1609 ms 24920 KB Output is correct
81 Correct 1783 ms 22492 KB Output is correct
82 Correct 1323 ms 25020 KB Output is correct
83 Correct 1881 ms 22716 KB Output is correct
84 Correct 1473 ms 25008 KB Output is correct
85 Correct 1939 ms 22752 KB Output is correct
86 Correct 1405 ms 24880 KB Output is correct
87 Correct 1806 ms 22496 KB Output is correct
88 Correct 650 ms 21836 KB Output is correct
89 Correct 769 ms 21952 KB Output is correct
90 Correct 1254 ms 23216 KB Output is correct
91 Correct 690 ms 21784 KB Output is correct
92 Correct 779 ms 22080 KB Output is correct
93 Correct 1527 ms 23588 KB Output is correct
94 Correct 2076 ms 23972 KB Output is correct
95 Correct 1662 ms 19828 KB Output is correct
96 Correct 1979 ms 24376 KB Output is correct
97 Correct 1517 ms 19804 KB Output is correct
98 Correct 1993 ms 23656 KB Output is correct
99 Correct 1202 ms 22888 KB Output is correct
100 Correct 885 ms 22320 KB Output is correct
101 Correct 833 ms 23456 KB Output is correct
102 Correct 622 ms 23140 KB Output is correct
103 Correct 2100 ms 21976 KB Output is correct
104 Correct 1216 ms 25100 KB Output is correct
105 Correct 1274 ms 22956 KB Output is correct
106 Correct 1073 ms 24056 KB Output is correct
107 Correct 1989 ms 22348 KB Output is correct
108 Correct 1218 ms 25036 KB Output is correct
109 Correct 1336 ms 22404 KB Output is correct
110 Correct 1205 ms 24604 KB Output is correct
111 Correct 1260 ms 23084 KB Output is correct
112 Correct 1109 ms 23956 KB Output is correct
113 Correct 709 ms 21820 KB Output is correct
114 Correct 489 ms 21412 KB Output is correct
115 Correct 1413 ms 23388 KB Output is correct
116 Correct 1208 ms 22724 KB Output is correct
117 Correct 536 ms 21476 KB Output is correct
118 Correct 1060 ms 20996 KB Output is correct
119 Correct 780 ms 22028 KB Output is correct
120 Correct 1335 ms 23136 KB Output is correct
121 Correct 1188 ms 22348 KB Output is correct
122 Correct 2062 ms 24016 KB Output is correct
123 Correct 1670 ms 19336 KB Output is correct
124 Correct 1711 ms 21796 KB Output is correct
125 Correct 1615 ms 19024 KB Output is correct
126 Correct 1677 ms 21116 KB Output is correct
127 Correct 1140 ms 22736 KB Output is correct
128 Correct 740 ms 21164 KB Output is correct
129 Correct 880 ms 23404 KB Output is correct
130 Correct 684 ms 23116 KB Output is correct