oj.uz

답안 #927744

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
927744 2024-02-15T09:47:18 Z boris_mihov Two Dishes (JOI19_dishes) C++17
65 / 100
 1393 ms 84372 KB 
#include <algorithm>
#include <iostream>
#include <numeric>
#include <cassert>
#include <vector>

#define int long long
typedef long long llong;
const int MAXN = 200000 + 10;
const int MAXLOG = 20;
const llong INF = 1e18;

int n, m;
template <typename T>
struct Fenwick
{
    T tree[MAXN];
    void update(int pos, T val)
    {
        for (int idx = pos ; idx <= m ; idx += idx & (-idx))
        {
            tree[idx] += val;
        }
    }

    T query(int pos)
    {
        T res = 0;
        for (int idx = pos ; idx > 0 ; idx -= idx & (-idx))
        {
            res += tree[idx];
        }

        return res;
    }

    int findKthZero(int k)
    {
        int idx = 0;
        for (int log = MAXLOG - 1 ; log >= 0 ; --log)
        {
            if (idx + (1 << log) <= m && (1 << log) - tree[idx + (1 << log)] < k)
            {
                idx += (1 << log);
                k -= (1 << log) - tree[idx];
            }
        }

        return idx + 1;
    }

    int findKthOne(int k)
    {
        int idx = 0;
        for (int log = MAXLOG - 1 ; log >= 0 ; --log)
        {
            if (idx + (1 << log) <= m && tree[idx + (1 << log)] < k)
            {
                idx += (1 << log);
                k -= tree[idx];
            }
        }

        return idx + 1;
    }
};

struct SegmentTree
{
    struct Node
    {
        llong value;
        llong lazy;

        Node()
        {
            value = lazy;
        }
    };

    Node tree[4*MAXN];
    void push(int node, int l, int r)
    {
        if (tree[node].lazy == 0)
        {
            return;
        }

        tree[node].value += tree[node].lazy;
        if (l < r)
        {
            tree[2*node].lazy += tree[node].lazy;
            tree[2*node + 1].lazy += tree[node].lazy;
        }

        tree[node].lazy = 0;
    }

    void rangeUpdate(int l, int r, int node, int queryL, int queryR, int queryVal)
    {
        push(node, l, r);
        if (queryR < l || r < queryL)
        {
            return;
        }

        if (queryL <= l && r <= queryR)
        {
            tree[node].lazy = queryVal;
            push(node, l, r);
            return;
        }

        int mid = (l + r) / 2;
        rangeUpdate(l, mid, 2*node, queryL, queryR, queryVal);
        rangeUpdate(mid + 1, r, 2*node + 1, queryL, queryR, queryVal);
    }

    void setUpdate(int l, int r, int node, int queryPos, llong queryVal)
    {
        push(node, l, r);
        if (queryPos < l || r < queryPos)
        {
            return;
        }

        if (l == r)
        {
            tree[node].value = queryVal;
            return;
        }

        int mid = (l + r) / 2;
        setUpdate(l, mid, 2*node, queryPos, queryVal);
        setUpdate(mid + 1, r, 2*node + 1, queryPos, queryVal);
    }

    llong query(int l, int r, int node, int queryPos)
    {
        push(node, l, r);
        if (l == r)
        {
            return tree[node].value;
        }

        int mid = (l + r) / 2;
        if (queryPos <= mid) return query(l, mid, 2*node, queryPos);
        else return query(mid + 1, r, 2*node + 1, queryPos);
    }

    void update(int pos, llong value)
    {
        setUpdate(1, m + 1, 1, pos, value);
    }

    void rangeUpdate(int l, int r, int value)
    {
        rangeUpdate(1, m + 1, 1, l, r, value);
    }

    llong query(int pos)
    {
        return query(1, m + 1, 1, pos);
    }
};

Fenwick <int> fenwickNext;
Fenwick <llong> fenwickActive;
SegmentTree dp;

struct Dish
{
    int time;
    llong limit;
    int reward;
    int idx;
    bool type;
};

Dish a[MAXN];
Dish b[MAXN];
llong prefixA[MAXN];
llong prefixB[MAXN];
bool isNext[MAXN];
bool isActive[MAXN];
llong dpBorderM[MAXN];

int globalRow;
llong findValue(int col)
{
    if (col == m + 1)
    {
        return dp.query(m + 1);
    }

    int cnt = col - 1 - fenwickNext.query(col - 1);
    int pos = m;
    
    if (cnt != m - fenwickNext.query(m))
    {
        // std::cout << "IN THE FUCKING IF: " << cnt << ' ' << m << ' ' << fenwickNext.query(m) << '\n';
        // std::cout << "next is\n";
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << fenwickNext.query(i) - fenwickNext.query(i - 1);
        // }

        // std::cout << '\n';

        // std::cout << "lapai\n";
        pos = fenwickNext.findKthZero(cnt + 1);
    }

    // if (col == 3) std::cout << "\n\n      value: " << col << ' ' << m - fenwickNext.query(m) << ' ' << cnt << ' ' << pos << ' ' << fenwickActive.query(pos - 1) - fenwickActive.query(col - 1) + dp[pos] << '\n';
    return fenwickActive.query(pos - 1) - fenwickActive.query(col - 1) + dp.query(pos);
}

void fix(int col)
{
    // std::cout << "fix: " << col << '\n';
    assert(col <= m);
    llong prevVal = findValue(col);
    llong curr = dp.query(col);
    llong next = findValue(col + 1) + fenwickActive.query(col) - fenwickActive.query(col - 1);
    // std::cout << "here: " << curr << ' ' << next << '\n';
    int res = fenwickNext.query(col) - fenwickNext.query(col - 1);
    fenwickNext.update(col, -res);

    int nextVal = 0;
    if (curr > next) 
    {
        fenwickNext.update(col, 0); // unessesary
    } else 
    {
        nextVal = 1;
        fenwickNext.update(col, 1);
    }

    // std::cout << "set: " << col << " = " << curr << ' ' << next << '\n';
    dp.update(col, std::max(curr, next));
    if (col > 1 && fenwickNext.query(col - 1) < col - 1)
    {
        // fix(col - 1);
        int cntZeroesToNow = col - 1 - fenwickNext.query(col - 1);
        int pos = fenwickNext.findKthZero(cntZeroesToNow);
        llong nextVal = findValue(pos + 1) + fenwickActive.query(pos) - fenwickActive.query(pos - 1);

        if (nextVal > dp.query(pos)) fix(pos);
        // if (prevVal <= dp[col])
        // {
        //     int cntBefore = col - 1 - fenwickNext.query(col - 1);
        //     for (int idx = col - 1 ; idx >= 1 ; --idx)
        //     {
        //         if (fenwickNext.query(idx) - fenwickNext.query(idx - 1) == 0)
        //         {
        //             fix(idx);
        //             return;
        //         }

        //         llong val = findValue(idx);
        //         fix(idx);
        //         llong val2 = findValue(idx);
        //         if (val != val2)
        //         {
        //             assert(fenwickNext.query(idx) - fenwickNext.query(idx - 1) == 0);
        //             exit(0);
        //         }

        //         assert(val == val2);
        //     }
        //     // std::cout << "cnt before: " << cntBefore << '\n';
        //     // if (cntBefore > 0)
        //     // {
        //     //     fix(fenwickNext.findKthZero(cntBefore));
        //     // }
        // } else
        // {
        //     // assert(false);
        //     int cntBefore = fenwickNext.query(col - 1);
        //     // std::cout << "cnt before: " << cntBefore << '\n';
        //     if (cntBefore > 0)
        //     {
        //         fix(fenwickNext.findKthOne(cntBefore));
        //     }
        // }
    }
}

void applyUpdate(int to, int val)
{
    dp.rangeUpdate(1, to, val);
}

std::vector <int> activateAt[MAXN];
void solve()
{
    for (int i = 1 ; i <= n ; ++i)
    {
        prefixA[i] = prefixA[i - 1] + a[i].time;
    }

    for (int i = 1 ; i <= m ; ++i)
    {
        prefixB[i] = prefixB[i - 1] + b[i].time;
    }

    for (int aPos = n ; aPos >= 1 ; --aPos)
    {
        dpBorderM[aPos] = dpBorderM[aPos + 1] + (prefixA[aPos - 1] + prefixB[m] + a[aPos].time <= a[aPos].limit ? a[aPos].reward : 0);
    }

    for (int i = 1 ; i <= m ; ++i)
    {
        int l = 0, r = n + 2, mid;
        while (l < r - 1)
        {
            mid = (l + r) / 2;
            if (prefixA[mid - 1] + prefixB[i] <= b[i].limit) l = mid;
            else r = mid;
        }

        activateAt[l].push_back(i);
        // std::cout << "here: " << i << ' ' << l << '\n';
    }

    globalRow = n + 1;
    for (int i = 1 ; i <= n ; ++i)
    {
        fenwickNext.update(i, 1);
        isNext[i] = true;
    }

    std::sort(activateAt[n + 1].begin(), activateAt[n + 1].end(), std::greater <int> ());
    for (const int &idx : activateAt[globalRow])
    {
        // std::cout << "activate: " << idx << '\n';
        fenwickActive.update(idx, b[idx].reward);
        fix(idx);
    }

    // std::cout << "dp after: " << n + 1 << '\n';
    // for (int i = 1 ; i <= m ; ++i)
    // {
    //     std::cout << findValue(i) << ' ';
    // } 

    // std::cout << '\n';

    for (globalRow = n ; globalRow >= 1 ; --globalRow)
    {
        // std::cout << "      global: " << globalRow << '\n';
        for (const int &idx : activateAt[globalRow])
        {
            dp.update(idx, findValue(idx));
        }
    
        int l = 0, r = m + 1, mid;
        while (l < r - 1)
        {
            mid = (l + r) / 2;
            if (prefixA[globalRow] + prefixB[mid - 1] <= a[globalRow].limit) l = mid;
            else r = mid;
        }

        if (l > 0)
        {
            dp.update(l, findValue(l));
        }

        for (const int &idx : activateAt[globalRow])
        {
            // std::cout << "      activate: " << idx << '\n';
            fenwickActive.update(idx, b[idx].reward);
        }

        if (l > 0) activateAt[globalRow].push_back(l);
        applyUpdate(l, a[globalRow].reward);

        dp.update(m + 1, dpBorderM[globalRow]);
        activateAt[globalRow].push_back(m);
        std::sort(activateAt[globalRow].begin(), activateAt[globalRow].end(), std::greater <int> ());

        // std::cout << "after applying\n";
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << findValue(i) << ' ';
        // } 

        // std::cout << '\n';

        // std::cout << "next is\n";
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << fenwickNext.query(i) - fenwickNext.query(i - 1);
        // }

        // std::cout << '\n';
        for (const int &idx : activateAt[globalRow])
        {
            // std::cout << "fix: " << idx << '\n';
            fix(idx);
            // if (idx > 1) fix(idx - 1);
        }

        // for (int idx = m ; idx >= 1 ; --idx)
        // {
        //     fix(idx);
        // }

        // std::cout << "dp after: " << globalRow << '\n';
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << findValue(i) << ' ';
        // } 

        // std::cout << '\n';
        // std::cout << "active\n";
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << isActive[i] << ' ';
        // }

        // std::cout << '\n';
        // std::cout << "next\n";
        // for (int i = 1 ; i <= m ; ++i)
        // {
        //     std::cout << isNext[i] << ' ';
        // }

        // std::cout << '\n';
    }

    globalRow++;
    std::cout << findValue(1) << '\n';
}

void input()
{
    std::cin >> n >> m;
    for (int i = 1 ; i <= n ; ++i)
    {
        std::cin >> a[i].time >> a[i].limit >> a[i].reward;
        a[i].idx = i;
        a[i].type = false;
    }

    for (int i = 1 ; i <= m ; ++i)
    {
        std::cin >> b[i].time >> b[i].limit >> b[i].reward;
        b[i].idx = i;
        a[i].type = true;
    }
}

void fastIOI()
{
    std::ios_base :: sync_with_stdio(0);
    std::cout.tie(nullptr);
    std::cin.tie(nullptr);
}

signed main()
{
    fastIOI();
    input();
    solve();

    return 0;
}

Compilation message

dishes.cpp: In function 'void fix(long long int)':
dishes.cpp:222:11: warning: unused variable 'prevVal' [-Wunused-variable]
  222 |     llong prevVal = findValue(col);
      |           ^~~~~~~
dishes.cpp:229:9: warning: variable 'nextVal' set but not used [-Wunused-but-set-variable]
  229 |     int nextVal = 0;
      |         ^~~~~~~
dishes.cpp: In constructor 'SegmentTree::Node::Node()':
dishes.cpp:77:21: warning: '*<unknown>.SegmentTree::Node::lazy' is used uninitialized in this function [-Wuninitialized]
   77 |             value = lazy;
      |                     ^~~~

Subtask #1
5.0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 497 ms 50396 KB Output is correct
2 Correct 616 ms 50116 KB Output is correct
3 Correct 399 ms 62408 KB Output is correct
4 Correct 414 ms 63080 KB Output is correct
5 Correct 7 ms 23388 KB Output is correct
6 Correct 576 ms 63024 KB Output is correct
7 Correct 253 ms 49448 KB Output is correct
8 Correct 95 ms 43628 KB Output is correct
9 Correct 422 ms 63588 KB Output is correct
10 Correct 647 ms 58356 KB Output is correct
11 Correct 371 ms 57028 KB Output is correct

Subtask #2
3.0 / 3.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 23388 KB Output is correct
2 Correct 10 ms 23384 KB Output is correct
3 Correct 7 ms 23380 KB Output is correct
4 Correct 7 ms 23384 KB Output is correct
5 Correct 9 ms 23388 KB Output is correct
6 Correct 7 ms 23388 KB Output is correct
7 Correct 9 ms 23384 KB Output is correct
8 Correct 8 ms 23380 KB Output is correct
9 Correct 8 ms 23384 KB Output is correct
10 Correct 8 ms 23388 KB Output is correct
11 Correct 7 ms 23388 KB Output is correct
12 Correct 7 ms 23376 KB Output is correct
13 Correct 7 ms 23384 KB Output is correct
14 Correct 9 ms 23388 KB Output is correct
15 Correct 9 ms 23388 KB Output is correct
16 Correct 7 ms 23388 KB Output is correct

Subtask #3
7.0 / 7.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 23388 KB Output is correct
2 Correct 10 ms 23384 KB Output is correct
3 Correct 7 ms 23380 KB Output is correct
4 Correct 7 ms 23384 KB Output is correct
5 Correct 9 ms 23388 KB Output is correct
6 Correct 7 ms 23388 KB Output is correct
7 Correct 9 ms 23384 KB Output is correct
8 Correct 8 ms 23380 KB Output is correct
9 Correct 8 ms 23384 KB Output is correct
10 Correct 8 ms 23388 KB Output is correct
11 Correct 7 ms 23388 KB Output is correct
12 Correct 7 ms 23376 KB Output is correct
13 Correct 7 ms 23384 KB Output is correct
14 Correct 9 ms 23388 KB Output is correct
15 Correct 9 ms 23388 KB Output is correct
16 Correct 7 ms 23388 KB Output is correct
17 Correct 11 ms 23592 KB Output is correct
18 Correct 10 ms 23388 KB Output is correct
19 Correct 16 ms 23388 KB Output is correct
20 Correct 11 ms 23588 KB Output is correct
21 Correct 13 ms 23568 KB Output is correct
22 Correct 15 ms 23388 KB Output is correct
23 Correct 16 ms 23388 KB Output is correct

Subtask #4
39.0 / 39.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 23388 KB Output is correct
2 Correct 10 ms 23384 KB Output is correct
3 Correct 7 ms 23380 KB Output is correct
4 Correct 7 ms 23384 KB Output is correct
5 Correct 9 ms 23388 KB Output is correct
6 Correct 7 ms 23388 KB Output is correct
7 Correct 9 ms 23384 KB Output is correct
8 Correct 8 ms 23380 KB Output is correct
9 Correct 8 ms 23384 KB Output is correct
10 Correct 8 ms 23388 KB Output is correct
11 Correct 7 ms 23388 KB Output is correct
12 Correct 7 ms 23376 KB Output is correct
13 Correct 7 ms 23384 KB Output is correct
14 Correct 9 ms 23388 KB Output is correct
15 Correct 9 ms 23388 KB Output is correct
16 Correct 7 ms 23388 KB Output is correct
17 Correct 11 ms 23592 KB Output is correct
18 Correct 10 ms 23388 KB Output is correct
19 Correct 16 ms 23388 KB Output is correct
20 Correct 11 ms 23588 KB Output is correct
21 Correct 13 ms 23568 KB Output is correct
22 Correct 15 ms 23388 KB Output is correct
23 Correct 16 ms 23388 KB Output is correct
24 Correct 388 ms 49104 KB Output is correct
25 Correct 372 ms 49132 KB Output is correct
26 Correct 474 ms 49516 KB Output is correct
27 Correct 414 ms 50228 KB Output is correct
28 Correct 669 ms 49392 KB Output is correct
29 Correct 401 ms 60736 KB Output is correct
30 Correct 1380 ms 61252 KB Output is correct
31 Correct 291 ms 47976 KB Output is correct
32 Correct 104 ms 41852 KB Output is correct
33 Correct 820 ms 59644 KB Output is correct
34 Correct 991 ms 60284 KB Output is correct
35 Correct 1353 ms 55416 KB Output is correct
36 Correct 1325 ms 54804 KB Output is correct

Subtask #5
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 23388 KB Output is correct
2 Correct 10 ms 23384 KB Output is correct
3 Correct 7 ms 23380 KB Output is correct
4 Correct 7 ms 23384 KB Output is correct
5 Correct 9 ms 23388 KB Output is correct
6 Correct 7 ms 23388 KB Output is correct
7 Correct 9 ms 23384 KB Output is correct
8 Correct 8 ms 23380 KB Output is correct
9 Correct 8 ms 23384 KB Output is correct
10 Correct 8 ms 23388 KB Output is correct
11 Correct 7 ms 23388 KB Output is correct
12 Correct 7 ms 23376 KB Output is correct
13 Correct 7 ms 23384 KB Output is correct
14 Correct 9 ms 23388 KB Output is correct
15 Correct 9 ms 23388 KB Output is correct
16 Correct 7 ms 23388 KB Output is correct
17 Correct 11 ms 23592 KB Output is correct
18 Correct 10 ms 23388 KB Output is correct
19 Correct 16 ms 23388 KB Output is correct
20 Correct 11 ms 23588 KB Output is correct
21 Correct 13 ms 23568 KB Output is correct
22 Correct 15 ms 23388 KB Output is correct
23 Correct 16 ms 23388 KB Output is correct
24 Correct 388 ms 49104 KB Output is correct
25 Correct 372 ms 49132 KB Output is correct
26 Correct 474 ms 49516 KB Output is correct
27 Correct 414 ms 50228 KB Output is correct
28 Correct 669 ms 49392 KB Output is correct
29 Correct 401 ms 60736 KB Output is correct
30 Correct 1380 ms 61252 KB Output is correct
31 Correct 291 ms 47976 KB Output is correct
32 Correct 104 ms 41852 KB Output is correct
33 Correct 820 ms 59644 KB Output is correct
34 Correct 991 ms 60284 KB Output is correct
35 Correct 1353 ms 55416 KB Output is correct
36 Correct 1325 ms 54804 KB Output is correct
37 Correct 502 ms 62908 KB Output is correct
38 Correct 422 ms 63836 KB Output is correct
39 Correct 531 ms 61796 KB Output is correct
40 Correct 744 ms 62056 KB Output is correct
41 Correct 7 ms 23384 KB Output is correct
42 Correct 1393 ms 64724 KB Output is correct
43 Correct 828 ms 62548 KB Output is correct
44 Correct 987 ms 63360 KB Output is correct
45 Correct 1365 ms 58192 KB Output is correct

Subtask #6
0 / 9.0

# 결과 실행 시간 메모리 Grader output
1 Correct 12 ms 23388 KB Output is correct
2 Correct 10 ms 23384 KB Output is correct
3 Correct 7 ms 23380 KB Output is correct
4 Correct 7 ms 23384 KB Output is correct
5 Correct 9 ms 23388 KB Output is correct
6 Correct 7 ms 23388 KB Output is correct
7 Correct 9 ms 23384 KB Output is correct
8 Correct 8 ms 23380 KB Output is correct
9 Correct 8 ms 23384 KB Output is correct
10 Correct 8 ms 23388 KB Output is correct
11 Correct 7 ms 23388 KB Output is correct
12 Correct 7 ms 23376 KB Output is correct
13 Correct 7 ms 23384 KB Output is correct
14 Correct 9 ms 23388 KB Output is correct
15 Correct 9 ms 23388 KB Output is correct
16 Correct 7 ms 23388 KB Output is correct
17 Correct 11 ms 23592 KB Output is correct
18 Correct 10 ms 23388 KB Output is correct
19 Correct 16 ms 23388 KB Output is correct
20 Correct 11 ms 23588 KB Output is correct
21 Correct 13 ms 23568 KB Output is correct
22 Correct 15 ms 23388 KB Output is correct
23 Correct 16 ms 23388 KB Output is correct
24 Correct 388 ms 49104 KB Output is correct
25 Correct 372 ms 49132 KB Output is correct
26 Correct 474 ms 49516 KB Output is correct
27 Correct 414 ms 50228 KB Output is correct
28 Correct 669 ms 49392 KB Output is correct
29 Correct 401 ms 60736 KB Output is correct
30 Correct 1380 ms 61252 KB Output is correct
31 Correct 291 ms 47976 KB Output is correct
32 Correct 104 ms 41852 KB Output is correct
33 Correct 820 ms 59644 KB Output is correct
34 Correct 991 ms 60284 KB Output is correct
35 Correct 1353 ms 55416 KB Output is correct
36 Correct 1325 ms 54804 KB Output is correct
37 Correct 502 ms 62908 KB Output is correct
38 Correct 422 ms 63836 KB Output is correct
39 Correct 531 ms 61796 KB Output is correct
40 Correct 744 ms 62056 KB Output is correct
41 Correct 7 ms 23384 KB Output is correct
42 Correct 1393 ms 64724 KB Output is correct
43 Correct 828 ms 62548 KB Output is correct
44 Correct 987 ms 63360 KB Output is correct
45 Correct 1365 ms 58192 KB Output is correct
46 Runtime error 211 ms 84372 KB Execution killed with signal 11
47 Halted 0 ms 0 KB -

Subtask #7
0 / 17.0

# 결과 실행 시간 메모리 Grader output
1 Correct 497 ms 50396 KB Output is correct
2 Correct 616 ms 50116 KB Output is correct
3 Correct 399 ms 62408 KB Output is correct
4 Correct 414 ms 63080 KB Output is correct
5 Correct 7 ms 23388 KB Output is correct
6 Correct 576 ms 63024 KB Output is correct
7 Correct 253 ms 49448 KB Output is correct
8 Correct 95 ms 43628 KB Output is correct
9 Correct 422 ms 63588 KB Output is correct
10 Correct 647 ms 58356 KB Output is correct
11 Correct 371 ms 57028 KB Output is correct
12 Correct 12 ms 23388 KB Output is correct
13 Correct 10 ms 23384 KB Output is correct
14 Correct 7 ms 23380 KB Output is correct
15 Correct 7 ms 23384 KB Output is correct
16 Correct 9 ms 23388 KB Output is correct
17 Correct 7 ms 23388 KB Output is correct
18 Correct 9 ms 23384 KB Output is correct
19 Correct 8 ms 23380 KB Output is correct
20 Correct 8 ms 23384 KB Output is correct
21 Correct 8 ms 23388 KB Output is correct
22 Correct 7 ms 23388 KB Output is correct
23 Correct 7 ms 23376 KB Output is correct
24 Correct 7 ms 23384 KB Output is correct
25 Correct 9 ms 23388 KB Output is correct
26 Correct 9 ms 23388 KB Output is correct
27 Correct 7 ms 23388 KB Output is correct
28 Correct 11 ms 23592 KB Output is correct
29 Correct 10 ms 23388 KB Output is correct
30 Correct 16 ms 23388 KB Output is correct
31 Correct 11 ms 23588 KB Output is correct
32 Correct 13 ms 23568 KB Output is correct
33 Correct 15 ms 23388 KB Output is correct
34 Correct 16 ms 23388 KB Output is correct
35 Correct 388 ms 49104 KB Output is correct
36 Correct 372 ms 49132 KB Output is correct
37 Correct 474 ms 49516 KB Output is correct
38 Correct 414 ms 50228 KB Output is correct
39 Correct 669 ms 49392 KB Output is correct
40 Correct 401 ms 60736 KB Output is correct
41 Correct 1380 ms 61252 KB Output is correct
42 Correct 291 ms 47976 KB Output is correct
43 Correct 104 ms 41852 KB Output is correct
44 Correct 820 ms 59644 KB Output is correct
45 Correct 991 ms 60284 KB Output is correct
46 Correct 1353 ms 55416 KB Output is correct
47 Correct 1325 ms 54804 KB Output is correct
48 Correct 502 ms 62908 KB Output is correct
49 Correct 422 ms 63836 KB Output is correct
50 Correct 531 ms 61796 KB Output is correct
51 Correct 744 ms 62056 KB Output is correct
52 Correct 7 ms 23384 KB Output is correct
53 Correct 1393 ms 64724 KB Output is correct
54 Correct 828 ms 62548 KB Output is correct
55 Correct 987 ms 63360 KB Output is correct
56 Correct 1365 ms 58192 KB Output is correct
57 Incorrect 569 ms 63160 KB Output isn't correct
58 Halted 0 ms 0 KB -

Subtask #8
0 / 9.0

# 결과 실행 시간 메모리 Grader output
1 Correct 497 ms 50396 KB Output is correct
2 Correct 616 ms 50116 KB Output is correct
3 Correct 399 ms 62408 KB Output is correct
4 Correct 414 ms 63080 KB Output is correct
5 Correct 7 ms 23388 KB Output is correct
6 Correct 576 ms 63024 KB Output is correct
7 Correct 253 ms 49448 KB Output is correct
8 Correct 95 ms 43628 KB Output is correct
9 Correct 422 ms 63588 KB Output is correct
10 Correct 647 ms 58356 KB Output is correct
11 Correct 371 ms 57028 KB Output is correct
12 Correct 12 ms 23388 KB Output is correct
13 Correct 10 ms 23384 KB Output is correct
14 Correct 7 ms 23380 KB Output is correct
15 Correct 7 ms 23384 KB Output is correct
16 Correct 9 ms 23388 KB Output is correct
17 Correct 7 ms 23388 KB Output is correct
18 Correct 9 ms 23384 KB Output is correct
19 Correct 8 ms 23380 KB Output is correct
20 Correct 8 ms 23384 KB Output is correct
21 Correct 8 ms 23388 KB Output is correct
22 Correct 7 ms 23388 KB Output is correct
23 Correct 7 ms 23376 KB Output is correct
24 Correct 7 ms 23384 KB Output is correct
25 Correct 9 ms 23388 KB Output is correct
26 Correct 9 ms 23388 KB Output is correct
27 Correct 7 ms 23388 KB Output is correct
28 Correct 11 ms 23592 KB Output is correct
29 Correct 10 ms 23388 KB Output is correct
30 Correct 16 ms 23388 KB Output is correct
31 Correct 11 ms 23588 KB Output is correct
32 Correct 13 ms 23568 KB Output is correct
33 Correct 15 ms 23388 KB Output is correct
34 Correct 16 ms 23388 KB Output is correct
35 Correct 388 ms 49104 KB Output is correct
36 Correct 372 ms 49132 KB Output is correct
37 Correct 474 ms 49516 KB Output is correct
38 Correct 414 ms 50228 KB Output is correct
39 Correct 669 ms 49392 KB Output is correct
40 Correct 401 ms 60736 KB Output is correct
41 Correct 1380 ms 61252 KB Output is correct
42 Correct 291 ms 47976 KB Output is correct
43 Correct 104 ms 41852 KB Output is correct
44 Correct 820 ms 59644 KB Output is correct
45 Correct 991 ms 60284 KB Output is correct
46 Correct 1353 ms 55416 KB Output is correct
47 Correct 1325 ms 54804 KB Output is correct
48 Correct 502 ms 62908 KB Output is correct
49 Correct 422 ms 63836 KB Output is correct
50 Correct 531 ms 61796 KB Output is correct
51 Correct 744 ms 62056 KB Output is correct
52 Correct 7 ms 23384 KB Output is correct
53 Correct 1393 ms 64724 KB Output is correct
54 Correct 828 ms 62548 KB Output is correct
55 Correct 987 ms 63360 KB Output is correct
56 Correct 1365 ms 58192 KB Output is correct
57 Runtime error 211 ms 84372 KB Execution killed with signal 11
58 Halted 0 ms 0 KB -