oj.uz

Submission #948626

# Submission time Handle Problem Language Result Execution time Memory
948626 2024-03-18T08:59:06 Z Nhoksocqt1 Soccer Stadium (IOI23_soccer) C++17
100 / 100
 1630 ms 600172 KB 
#include<bits/stdc++.h>
using namespace std;

#define inf 0x3f3f3f3f
#define sz(x) int((x).size())
#define fi first
#define se second
typedef long long ll;
typedef pair<int, int> ii;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int Random(int l, int r) {
    return uniform_int_distribution<int>(l, r)(rng);
}

const int MAXN = 2003;
const int MAXM = 303;
const int lx[] = {-1, 0, 0, 1}, ly[] = {0, -1, 1, 0};

struct State {
    int x, y, t;

    State(int _x = 0, int _y = 0, int _t = 0) : x(_x), y(_y), t(_t) {};
};

ii range[MAXN], max_rec[MAXM][MAXM][MAXM];
int f[MAXN * MAXN], nxt[2][MAXN][MAXN], dp[2][MAXM][MAXM][MAXM];
int sum[MAXN][MAXN], up[MAXN][MAXN], down[MAXN][MAXN], nSize;
bool dx[MAXN][MAXN][4], tmp[MAXN][MAXN], isTree[MAXN][MAXN];

bool checkGrid2(void) {
    int minL(nSize), maxR(0);
    bool ok(0);
    for (int i = 1; i <= nSize; ++i) {
        range[i] = {0, 0};
        bool hasEmpty(0);
        for (int j = 1; j <= nSize; ++j) {
            if(hasEmpty && isTree[i][j - 1] && !isTree[i][j])
                return false;

            hasEmpty |= (!isTree[i][j]);
            if(!isTree[i][j]) {
                range[i].se = j;
                if(!range[i].fi)
                    range[i].fi = j;
            }
        }

        if(ok && range[i].fi > 0 && range[i - 1].fi == 0)
            return false;

        ok |= (range[i].fi > 0);
        if(range[i].fi > 0)
            minL = min(minL, range[i].fi);

        maxR = max(maxR, range[i].se);
    }

    int upL(-1), upR(-1), downL(-1), downR(-1);
    int leftL(-1), leftR(-1), rightL(-1), rightR(-1);
    bool descL(0), descR(0);
    for (int i = 1; i <= nSize; ++i) {
        if(range[i].fi == 0)
            continue;

        if(i > 2 && descL && range[i - 1].fi > range[i].fi)
            return false;

        if(i > 2 && descR && range[i - 1].se < range[i].se)
            return false;

        if(i > 1 && range[i - 1].fi > 0 && range[i - 1].fi < range[i].fi)
            descL = 1;

        if(i > 1 && range[i - 1].se > 0 && range[i - 1].se > range[i].se)
            descR = 1;

        if(upL < 0)
            upL = range[i].fi, upR = range[i].se;

        downL = range[i].fi, downR = range[i].se;
        if(range[i].fi == minL) {
            leftR = i;
            if(leftL < 0)
                leftL = i;
        }

        if(range[i].se == maxR) {
            rightR = i;
            if(rightL < 0)
                rightL = i;
        }
    }

    for (int i = 1; i <= nSize; ++i) {
        if(range[i].fi <= 0)
            continue;

        int nowL = range[i].fi, nowR = range[i].se;
        if(!(nowL <= upL && upR <= nowR || upL <= nowL && nowR <= upR) || !(nowL <= downL && downR <= nowR || downL <= nowL && nowR <= downR))
            return false;
    }

    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j) {
            if(!isTree[j][i]) {
                int k(j);
                while(k <= nSize && !isTree[k][i])
                    ++k;

                --k;
                if(!(j <= leftL && leftR <= k || leftL <= j && k <= leftR) || !(j <= rightL && rightR <= k || rightL <= j && k <= rightR))
                    return false;

                break;
            }
        }
    }

    return true;
}

int calc(int i, int j) {
    return (i - 1 + j - 1) * nSize - (i - 1) * (j - 1);
}

int sub1(void) {
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j) {
            if(isTree[i][j]) {
                return max({calc(i, j), calc(nSize - i + 1, j), calc(i, nSize - j + 1), calc(nSize - i + 1, nSize - j + 1)});
            }
        }
    }

    abort();
}

int sub2(void) {
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j)
            tmp[i][j] = isTree[i][j];
    }

    int res(0);
    for (int mask = 0; mask < (1 << (nSize * nSize)); ++mask) {
        if(__builtin_popcount(mask) <= res)
            continue;

        bool check(1);
        for (int i = 1; i <= nSize; ++i) {
            for (int j = 1; j <= nSize; ++j) {
                if((mask >> ((i - 1) * nSize + j - 1) & 1) && isTree[i][j])
                    check = 0;

                isTree[i][j] = !(mask >> ((i - 1) * nSize + j - 1) & 1);
            }
        }

        if(check && checkGrid2())
            res = __builtin_popcount(mask);

        for (int i = 1; i <= nSize; ++i) {
            for (int j = 1; j <= nSize; ++j)
                isTree[i][j] = tmp[i][j];
        }
    }

    return res;
}

inline int getSum(int x, int y, int u, int v) {
    return sum[u][v] - sum[u][y - 1] - sum[x - 1][v] + sum[x - 1][y - 1];
}

int sub4(void) {
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j)
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + isTree[i][j];
    }

    for (int l = 1; l <= nSize; ++l) {
        for (int r = l; r <= nSize; ++r) {
            for (int i = 1; i <= nSize; ++i) {
                dp[0][i][l][r] = dp[1][i][l][r] = 0;
            }
        }
    }

    for (int i = 1; i <= nSize; ++i) {
        for (int l = 1; l <= nSize; ++l) {
            for (int r = l; r <= nSize; ++r) {
                if(isTree[i][r])
                    break;

                dp[1][i][l][r] = r - l + 1;
            }
        }
    }

    int res(0);
    for (int len = 1; len <= nSize; ++len) {
        int pre(len & 1), cur(!pre);
        for (int i = 1; i + len - 1 <= nSize; ++i) {
            int j(i + len - 1);
            for (int l = 1; l <= nSize; ++l) {
                for (int r = nSize; r >= l; --r) {
                    if(!dp[pre][i][l][r])
                        continue;

                    if(i > 1 && getSum(i - 1, l, i - 1, r) == 0)
                        dp[cur][i - 1][l][r] = max(dp[cur][i - 1][l][r], dp[pre][i][l][r] + r - l + 1);

                    if(j < nSize && getSum(j + 1, l, j + 1, r) == 0)
                        dp[cur][i][l][r] = max(dp[cur][i][l][r], dp[pre][i][l][r] + r - l + 1);

                    if(l < r) {
                        dp[pre][i][l + 1][r] = max(dp[pre][i][l + 1][r], dp[pre][i][l][r]);
                        dp[pre][i][l][r - 1] = max(dp[pre][i][l][r - 1], dp[pre][i][l][r]);
                    }

                    res = max(res, dp[pre][i][l][r]);
                    dp[pre][i][l][r] = 0;
                }
            }
        }
    }

    return res;
}

int sub5(void) {
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j)
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + isTree[i][j];
    }

    for (int l = 1; l <= nSize; ++l) {
        for (int r = l; r <= nSize; ++r) {
            int j(1);
            for (int i = 1; i <= nSize; ++i) {
                j = max(j, i);
                while(j < nSize && getSum(i, l, j + 1, r) == 0)
                    ++j;

                max_rec[i][l][r].se = j;
            }

            j = nSize;
            for (int i = nSize; i > 0; --i) {
                j = min(j, i);
                while(j > 1 && getSum(j - 1, l, i, r) == 0)
                    --j;

                max_rec[i][l][r].fi = j;
            }
        }
    }

    for (int i = 1; i <= nSize; ++i) {
        for (int l = 1; l <= nSize; ++l) {
            for (int r = l; r <= nSize; ++r) {
                if(max_rec[i][l][r].fi == i && getSum(i, l, i, r) == 0) {
                    dp[0][i][l][r] = (max_rec[i][l][r].se - max_rec[i][l][r].fi + 1) * (r - l + 1);
                } else {
                    dp[0][i][l][r] = 0;
                }
            }
        }
    }

    int res(0);
    for (int i = nSize; i > 0; --i) {
        for (int l = 1; l <= nSize; ++l) {
            for (int r = nSize; r >= l; --r) {
                if(!dp[0][i][l][r])
                    continue;

                int recSize = max_rec[i][l][r].se - max_rec[i][l][r].fi;
                if(l < r) {
                    ii new_rec = max_rec[i][l + 1][r];
                    dp[0][i][l + 1][r] = max(dp[0][i][l + 1][r], dp[0][i][l][r] + (new_rec.se - new_rec.fi - recSize) * (r - l));

                    new_rec = max_rec[i][l][r - 1];
                    dp[0][i][l][r - 1] = max(dp[0][i][l][r - 1], dp[0][i][l][r] + (new_rec.se - new_rec.fi - recSize) * (r - l));
                }

                res = max(res, dp[0][i][l][r]);
                dp[0][i][l][r] = 0;
            }
        }
    }

    return res;
}

template<int LOG = 12> struct SparseTable {
    array<array<int, LOG>, MAXN> P;

    SparseTable() {};

    SparseTable(int N, int C[]) {
        for (int i = 1; i <= N; ++i)
            P[i][0] = C[i];

        for (int j = 1; (1 << j) <= N; ++j) {
            for (int i = 1; i + (1 << j) - 1 <= N; ++i)
                P[i][j] = min(P[i][j - 1], P[i + (1 << (j - 1))][j - 1]);
        }
    }

    int query(int l, int r) {
        int log = 31 - __builtin_clz(r - l + 1);
        return min(P[l][log], P[r - (1 << log) + 1][log]);
    }

};

SparseTable<> up_rmq[MAXN], down_rmq[MAXN];

vector<array<int, 4>> rects;
map<array<int, 4>, int> idRec;

void gen_rectangle(void) {
    for (int i = 1; i <= nSize; ++i) {
        stack<array<int, 4>> st;
        for (int j = 1; j <= nSize + 1; ++j) {
            int cur_h = (j <= nSize) ? up[i][j] : 0;
            int cur_start = j, cur_w = 1, cur_based = (i == nSize || isTree[i + 1][j]);

            while(sz(st) && st.top()[2] >= cur_h) {
                array<int, 4> p(st.top()); st.pop();
                int start(p[0]), w(p[1]), h(p[2]), based(p[3]);

                cur_w += w;
                cur_based |= based;
                if(cur_based && h > cur_h) {
                    rects.push_back({i - h + 1, start, i, start + cur_w - 2});
                    idRec[rects.back()] = sz(rects) - 1;
                }

                cur_start = start;
            }

            st.push({cur_start, cur_w, cur_h, cur_based});
        }
    }
}

void init(void) {
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j) {
            up[i][j] = (isTree[i][j]) ? 0 : 1 + up[i - 1][j];
            down[nSize - i + 1][j] = (isTree[nSize - i + 1][j]) ? 0 : 1 + down[nSize - i + 2][j];
        }

        nxt[0][i][nSize] = nxt[1][i][nSize] = nSize + 1;
        for (int j = nSize - 1; j > 0; --j) {
            int c(isTree[i][j + 1]);
            nxt[c][i][j] = j + 1;
            nxt[1 - c][i][j] = nxt[1 - c][i][j + 1];
        }
    }

    for (int i = 1; i <= nSize; ++i) {
        up_rmq[i] = SparseTable<>(nSize, up[i]);
        down_rmq[i] = SparseTable<>(nSize, down[i]);
    }

    gen_rectangle();
}

int solve(int id_rec) {
    int &ans(f[id_rec]);
    if(ans != -1)
        return ans;

    int a = rects[id_rec][0], b = rects[id_rec][1];
    int c = rects[id_rec][2], d = rects[id_rec][3];
    int area = (c - a + 1) * (d - b + 1);

    ans = area;
    if(a > 1) {
        int start = (!isTree[a - 1][b]) ? b : nxt[0][a - 1][b];
        for (int l = start; l <= d; ) {
            int r = min(d, nxt[1][a - 1][l] - 1);
            if(l == b && r == d)
                break;

            int u = a - up_rmq[a].query(l, r) + 1;
            int d = c + down_rmq[c].query(l, r) - 1;

            if(idRec.find({u, l, d, r}) != idRec.end()) {
                int new_id_rec = idRec[{u, l, d, r}];
                ans = max(ans, area + solve(new_id_rec) - (c - a + 1) * (r - l + 1));
            }

            l = nxt[0][a - 1][r];
        }
    }

    if(c < nSize) {
        int start = (!isTree[c + 1][b]) ? b : nxt[0][c + 1][b];
        for (int l = start; l <= d; ) {
            int r = min(d, nxt[1][c + 1][l] - 1);
            if(l == b && r == d)
                break;

            int u = a - up_rmq[a].query(l, r) + 1;
            int d = c + down_rmq[c].query(l, r) - 1;

            if(idRec.find({u, l, d, r}) != idRec.end()) {
                int new_id_rec = idRec[{u, l, d, r}];
                ans = max(ans, area + solve(new_id_rec) - (c - a + 1) * (r - l + 1));
            }

            l = nxt[0][c + 1][r];
        }
    }

    return ans;
}

int magicFunc(void) {
    init();
    for (int i = 0; i < sz(rects); ++i)
        f[i] = -1;

    int res(0);
    for (int i = 0; i < sz(rects); ++i)
        res = max(res, solve(i));

    return res;
}

int biggest_stadium(int n, vector<vector<int>> F) {
    nSize = n;

    int cntTree(0);
    for (int i = 1; i <= nSize; ++i) {
        for (int j = 1; j <= nSize; ++j) {
            isTree[i][j] = (F[i - 1][j - 1]);
            cntTree += isTree[i][j];
        }
    }

    if(cntTree == 1)
        return sub1();

    if(nSize <= 3)
        return sub2();

    if(cntTree == 0 || checkGrid2())
        return nSize * nSize - cntTree;

    if(nSize <= 30)
        return sub4();

    if(nSize <= 300)
        return sub5();

    return magicFunc();
}

#ifdef Nhoksocqt1

int main(void) {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    #define TASK "soccer"
    if(fopen(TASK".inp", "r")) {
        freopen(TASK".inp", "r", stdin);
        freopen(TASK".out", "w", stdout);
    }

    vector<vector<int>> F;
    int n;
    cin >> n;

    F.resize(n);
    for (int i = 0; i < n; ++i) {
        F[i].resize(n);
        for (int j = 0; j < n; ++j) {
            cin >> F[i][j];
            //F[i][j] = min(1, max(0, Random(-4, 1))); cout << F[i][j] << " \n"[j + 1 == n];
        }
    }

    int ans = biggest_stadium(n, F);
    cout << "ANSWER: " << ans << '\n';

    return 0;
}

#endif // Nhoksocqt1

Compilation message

soccer.cpp: In function 'bool checkGrid2()':
soccer.cpp:100:26: warning: suggest parentheses around '&&' within '||' [-Wparentheses]
  100 |         if(!(nowL <= upL && upR <= nowR || upL <= nowL && nowR <= upR) || !(nowL <= downL && downR <= nowR || downL <= nowL && nowR <= downR))
      |              ~~~~~~~~~~~~^~~~~~~~~~~~~~
soccer.cpp:100:91: warning: suggest parentheses around '&&' within '||' [-Wparentheses]
  100 |         if(!(nowL <= upL && upR <= nowR || upL <= nowL && nowR <= upR) || !(nowL <= downL && downR <= nowR || downL <= nowL && nowR <= downR))
      |                                                                             ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~
soccer.cpp:112:33: warning: suggest parentheses around '&&' within '||' [-Wparentheses]
  112 |                 if(!(j <= leftL && leftR <= k || leftL <= j && k <= leftR) || !(j <= rightL && rightR <= k || rightL <= j && k <= rightR))
      |                      ~~~~~~~~~~~^~~~~~~~~~~~~
soccer.cpp:112:93: warning: suggest parentheses around '&&' within '||' [-Wparentheses]
  112 |                 if(!(j <= leftL && leftR <= k || leftL <= j && k <= leftR) || !(j <= rightL && rightR <= k || rightL <= j && k <= rightR))
      |                                                                                 ~~~~~~~~~~~~^~~~~~~~~~~~~~

Subtask #0
0.0 / 0.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 8540 KB ok

Subtask #1
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 4444 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 6492 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 2 ms 4444 KB ok
8 Correct 16 ms 8540 KB ok
9 Correct 249 ms 40016 KB ok

Subtask #2
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 4444 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 6488 KB ok
4 Correct 1 ms 6744 KB ok
5 Correct 1 ms 6492 KB ok
6 Correct 1 ms 6492 KB ok
7 Correct 1 ms 6492 KB ok
8 Correct 1 ms 6492 KB ok
9 Correct 1 ms 6492 KB ok
10 Correct 1 ms 6492 KB ok
11 Correct 1 ms 6488 KB ok
12 Correct 1 ms 6488 KB ok
13 Correct 1 ms 6492 KB ok

Subtask #3
22.0 / 22.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 8540 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 6488 KB ok
5 Correct 1 ms 6744 KB ok
6 Correct 1 ms 6492 KB ok
7 Correct 1 ms 6492 KB ok
8 Correct 1 ms 6492 KB ok
9 Correct 1 ms 6492 KB ok
10 Correct 1 ms 6492 KB ok
11 Correct 1 ms 6492 KB ok
12 Correct 1 ms 6488 KB ok
13 Correct 1 ms 6488 KB ok
14 Correct 1 ms 6492 KB ok
15 Correct 2 ms 12644 KB ok
16 Correct 2 ms 12632 KB ok
17 Correct 2 ms 12636 KB ok
18 Correct 2 ms 12636 KB ok
19 Correct 2 ms 12636 KB ok
20 Correct 1 ms 4696 KB ok
21 Correct 1 ms 4444 KB ok
22 Correct 2 ms 12636 KB ok
23 Correct 2 ms 12636 KB ok
24 Correct 2 ms 12636 KB ok
25 Correct 2 ms 12636 KB ok
26 Correct 2 ms 12636 KB ok

Subtask #4
18.0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 8540 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 6488 KB ok
7 Correct 1 ms 6744 KB ok
8 Correct 1 ms 6492 KB ok
9 Correct 1 ms 6492 KB ok
10 Correct 1 ms 6492 KB ok
11 Correct 1 ms 6492 KB ok
12 Correct 1 ms 6492 KB ok
13 Correct 1 ms 6492 KB ok
14 Correct 1 ms 6488 KB ok
15 Correct 1 ms 6488 KB ok
16 Correct 1 ms 6492 KB ok
17 Correct 2 ms 12644 KB ok
18 Correct 2 ms 12632 KB ok
19 Correct 2 ms 12636 KB ok
20 Correct 2 ms 12636 KB ok
21 Correct 2 ms 12636 KB ok
22 Correct 1 ms 4696 KB ok
23 Correct 1 ms 4444 KB ok
24 Correct 2 ms 12636 KB ok
25 Correct 2 ms 12636 KB ok
26 Correct 2 ms 12636 KB ok
27 Correct 2 ms 12636 KB ok
28 Correct 2 ms 12636 KB ok
29 Correct 2 ms 12636 KB ok
30 Correct 4 ms 29100 KB ok
31 Correct 4 ms 29276 KB ok
32 Correct 4 ms 29276 KB ok
33 Correct 4 ms 29284 KB ok
34 Correct 1 ms 4444 KB ok
35 Correct 1 ms 4440 KB ok
36 Correct 4 ms 29276 KB ok
37 Correct 4 ms 29276 KB ok
38 Correct 4 ms 29272 KB ok
39 Correct 4 ms 29276 KB ok
40 Correct 5 ms 29276 KB ok
41 Correct 4 ms 29276 KB ok

Subtask #5
16.0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 8540 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 6488 KB ok
7 Correct 1 ms 6744 KB ok
8 Correct 1 ms 6492 KB ok
9 Correct 1 ms 6492 KB ok
10 Correct 1 ms 6492 KB ok
11 Correct 1 ms 6492 KB ok
12 Correct 1 ms 6492 KB ok
13 Correct 1 ms 6492 KB ok
14 Correct 1 ms 6488 KB ok
15 Correct 1 ms 6488 KB ok
16 Correct 1 ms 6492 KB ok
17 Correct 2 ms 12644 KB ok
18 Correct 2 ms 12632 KB ok
19 Correct 2 ms 12636 KB ok
20 Correct 2 ms 12636 KB ok
21 Correct 2 ms 12636 KB ok
22 Correct 1 ms 4696 KB ok
23 Correct 1 ms 4444 KB ok
24 Correct 2 ms 12636 KB ok
25 Correct 2 ms 12636 KB ok
26 Correct 2 ms 12636 KB ok
27 Correct 2 ms 12636 KB ok
28 Correct 2 ms 12636 KB ok
29 Correct 2 ms 12636 KB ok
30 Correct 4 ms 29100 KB ok
31 Correct 4 ms 29276 KB ok
32 Correct 4 ms 29276 KB ok
33 Correct 4 ms 29284 KB ok
34 Correct 1 ms 4444 KB ok
35 Correct 1 ms 4440 KB ok
36 Correct 4 ms 29276 KB ok
37 Correct 4 ms 29276 KB ok
38 Correct 4 ms 29272 KB ok
39 Correct 4 ms 29276 KB ok
40 Correct 5 ms 29276 KB ok
41 Correct 4 ms 29276 KB ok
42 Correct 98 ms 130504 KB ok
43 Correct 102 ms 132036 KB ok
44 Correct 56 ms 126668 KB ok
45 Correct 47 ms 126156 KB ok
46 Correct 82 ms 128964 KB ok
47 Correct 36 ms 125524 KB ok
48 Correct 17 ms 8536 KB ok
49 Correct 38 ms 127572 KB ok
50 Correct 80 ms 132000 KB ok
51 Correct 44 ms 128980 KB ok
52 Correct 37 ms 127824 KB ok
53 Correct 37 ms 127572 KB ok
54 Correct 37 ms 127828 KB ok
55 Correct 37 ms 127824 KB ok
56 Correct 37 ms 126032 KB ok
57 Correct 85 ms 130504 KB ok
58 Correct 76 ms 131220 KB ok
59 Correct 82 ms 131880 KB ok

Subtask #6
30.0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 8540 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 6492 KB ok
7 Correct 1 ms 4444 KB ok
8 Correct 2 ms 4444 KB ok
9 Correct 16 ms 8540 KB ok
10 Correct 249 ms 40016 KB ok
11 Correct 1 ms 6488 KB ok
12 Correct 1 ms 6744 KB ok
13 Correct 1 ms 6492 KB ok
14 Correct 1 ms 6492 KB ok
15 Correct 1 ms 6492 KB ok
16 Correct 1 ms 6492 KB ok
17 Correct 1 ms 6492 KB ok
18 Correct 1 ms 6492 KB ok
19 Correct 1 ms 6488 KB ok
20 Correct 1 ms 6488 KB ok
21 Correct 1 ms 6492 KB ok
22 Correct 2 ms 12644 KB ok
23 Correct 2 ms 12632 KB ok
24 Correct 2 ms 12636 KB ok
25 Correct 2 ms 12636 KB ok
26 Correct 2 ms 12636 KB ok
27 Correct 1 ms 4696 KB ok
28 Correct 1 ms 4444 KB ok
29 Correct 2 ms 12636 KB ok
30 Correct 2 ms 12636 KB ok
31 Correct 2 ms 12636 KB ok
32 Correct 2 ms 12636 KB ok
33 Correct 2 ms 12636 KB ok
34 Correct 2 ms 12636 KB ok
35 Correct 4 ms 29100 KB ok
36 Correct 4 ms 29276 KB ok
37 Correct 4 ms 29276 KB ok
38 Correct 4 ms 29284 KB ok
39 Correct 1 ms 4444 KB ok
40 Correct 1 ms 4440 KB ok
41 Correct 4 ms 29276 KB ok
42 Correct 4 ms 29276 KB ok
43 Correct 4 ms 29272 KB ok
44 Correct 4 ms 29276 KB ok
45 Correct 5 ms 29276 KB ok
46 Correct 4 ms 29276 KB ok
47 Correct 98 ms 130504 KB ok
48 Correct 102 ms 132036 KB ok
49 Correct 56 ms 126668 KB ok
50 Correct 47 ms 126156 KB ok
51 Correct 82 ms 128964 KB ok
52 Correct 36 ms 125524 KB ok
53 Correct 17 ms 8536 KB ok
54 Correct 38 ms 127572 KB ok
55 Correct 80 ms 132000 KB ok
56 Correct 44 ms 128980 KB ok
57 Correct 37 ms 127824 KB ok
58 Correct 37 ms 127572 KB ok
59 Correct 37 ms 127828 KB ok
60 Correct 37 ms 127824 KB ok
61 Correct 37 ms 126032 KB ok
62 Correct 85 ms 130504 KB ok
63 Correct 76 ms 131220 KB ok
64 Correct 82 ms 131880 KB ok
65 Correct 1596 ms 563812 KB ok
66 Correct 787 ms 553588 KB ok
67 Correct 579 ms 508072 KB ok
68 Correct 517 ms 482708 KB ok
69 Correct 874 ms 499656 KB ok
70 Correct 1105 ms 515144 KB ok
71 Correct 490 ms 481196 KB ok
72 Correct 459 ms 479280 KB ok
73 Correct 268 ms 39972 KB ok
74 Correct 261 ms 40020 KB ok
75 Correct 466 ms 479524 KB ok
76 Correct 1213 ms 560440 KB ok
77 Correct 1171 ms 560532 KB ok
78 Correct 538 ms 492164 KB ok
79 Correct 521 ms 487176 KB ok
80 Correct 510 ms 485824 KB ok
81 Correct 522 ms 486412 KB ok
82 Correct 620 ms 491964 KB ok
83 Correct 722 ms 511096 KB ok
84 Correct 491 ms 479596 KB ok
85 Correct 461 ms 479316 KB ok
86 Correct 469 ms 479572 KB ok
87 Correct 520 ms 480836 KB ok
88 Correct 465 ms 479316 KB ok
89 Correct 466 ms 479612 KB ok
90 Correct 478 ms 479992 KB ok
91 Correct 472 ms 479828 KB ok
92 Correct 551 ms 495628 KB ok
93 Correct 595 ms 503992 KB ok
94 Correct 517 ms 485560 KB ok
95 Correct 491 ms 482260 KB ok
96 Correct 494 ms 481488 KB ok
97 Correct 515 ms 480884 KB ok
98 Correct 478 ms 480032 KB ok
99 Correct 1630 ms 600172 KB ok
100 Correct 1257 ms 560824 KB ok
101 Correct 1227 ms 553132 KB ok
102 Correct 1233 ms 561084 KB ok
103 Correct 1324 ms 577684 KB ok
104 Correct 1463 ms 581232 KB ok
105 Correct 1507 ms 584352 KB ok
106 Correct 1484 ms 588124 KB ok
107 Correct 1485 ms 586916 KB ok
108 Correct 889 ms 533892 KB ok
109 Correct 790 ms 535400 KB ok