oj.uz

답안 #948620

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
948620 2024-03-18T08:55:25 Z Nhoksocqt1 축구 경기장 (IOI23_soccer) C++17
65.5 / 100
 1494 ms 587948 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;
                if(based && h > cur_h) {
                    rects.push_back({i - h + 1, start, i, start + cur_w - 2});
                    idRec[rects.back()] = sz(rects) - 1;
                }

                cur_based |= based;
                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

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 8540 KB ok

Subtask #1
6.0 / 6.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 4444 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 4452 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 6500 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 4444 KB ok
8 Correct 19 ms 8352 KB ok
9 Correct 256 ms 39972 KB ok

Subtask #2
8.0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 4444 KB ok
2 Correct 1 ms 4444 KB ok
3 Correct 1 ms 6492 KB ok
4 Correct 1 ms 6492 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 6492 KB ok
12 Correct 1 ms 6492 KB ok
13 Correct 1 ms 6488 KB ok

Subtask #3
22.0 / 22.0

# 결과 실행 시간 메모리 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 6492 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 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 2 ms 12636 KB ok
16 Correct 2 ms 12636 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 4444 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

# 결과 실행 시간 메모리 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 4452 KB ok
5 Correct 1 ms 4444 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 6492 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 6488 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 2 ms 12636 KB ok
21 Correct 2 ms 12636 KB ok
22 Correct 1 ms 4444 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 7 ms 29276 KB ok
31 Correct 5 ms 29276 KB ok
32 Correct 4 ms 29276 KB ok
33 Correct 5 ms 29256 KB ok
34 Correct 1 ms 4444 KB ok
35 Correct 1 ms 4444 KB ok
36 Correct 6 ms 29276 KB ok
37 Correct 4 ms 29264 KB ok
38 Correct 7 ms 29276 KB ok
39 Correct 5 ms 29276 KB ok
40 Correct 4 ms 29276 KB ok
41 Correct 5 ms 29276 KB ok

Subtask #5
4.0 / 16.0

# 결과 실행 시간 메모리 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 4452 KB ok
5 Correct 1 ms 4444 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 6492 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 6488 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 2 ms 12636 KB ok
21 Correct 2 ms 12636 KB ok
22 Correct 1 ms 4444 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 7 ms 29276 KB ok
31 Correct 5 ms 29276 KB ok
32 Correct 4 ms 29276 KB ok
33 Correct 5 ms 29256 KB ok
34 Correct 1 ms 4444 KB ok
35 Correct 1 ms 4444 KB ok
36 Correct 6 ms 29276 KB ok
37 Correct 4 ms 29264 KB ok
38 Correct 7 ms 29276 KB ok
39 Correct 5 ms 29276 KB ok
40 Correct 4 ms 29276 KB ok
41 Correct 5 ms 29276 KB ok
42 Partially correct 106 ms 128740 KB partial
43 Correct 82 ms 129736 KB ok
44 Partially correct 50 ms 126360 KB partial
45 Partially correct 43 ms 126056 KB partial
46 Partially correct 68 ms 127432 KB partial
47 Partially correct 37 ms 125520 KB partial
48 Correct 17 ms 8536 KB ok
49 Correct 39 ms 127720 KB ok
50 Correct 52 ms 127056 KB ok
51 Correct 44 ms 128976 KB ok
52 Partially correct 47 ms 127940 KB partial
53 Correct 38 ms 127612 KB ok
54 Partially correct 37 ms 127572 KB partial
55 Partially correct 38 ms 127772 KB partial
56 Correct 38 ms 126036 KB ok
57 Correct 72 ms 130540 KB ok
58 Correct 78 ms 131264 KB ok
59 Correct 82 ms 131780 KB ok

Subtask #6
7.5 / 30.0

# 결과 실행 시간 메모리 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 4452 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 6500 KB ok
7 Correct 1 ms 4444 KB ok
8 Correct 1 ms 4444 KB ok
9 Correct 19 ms 8352 KB ok
10 Correct 256 ms 39972 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 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 6492 KB ok
20 Correct 1 ms 6492 KB ok
21 Correct 1 ms 6488 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
27 Correct 1 ms 4444 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 7 ms 29276 KB ok
36 Correct 5 ms 29276 KB ok
37 Correct 4 ms 29276 KB ok
38 Correct 5 ms 29256 KB ok
39 Correct 1 ms 4444 KB ok
40 Correct 1 ms 4444 KB ok
41 Correct 6 ms 29276 KB ok
42 Correct 4 ms 29264 KB ok
43 Correct 7 ms 29276 KB ok
44 Correct 5 ms 29276 KB ok
45 Correct 4 ms 29276 KB ok
46 Correct 5 ms 29276 KB ok
47 Partially correct 106 ms 128740 KB partial
48 Correct 82 ms 129736 KB ok
49 Partially correct 50 ms 126360 KB partial
50 Partially correct 43 ms 126056 KB partial
51 Partially correct 68 ms 127432 KB partial
52 Partially correct 37 ms 125520 KB partial
53 Correct 17 ms 8536 KB ok
54 Correct 39 ms 127720 KB ok
55 Correct 52 ms 127056 KB ok
56 Correct 44 ms 128976 KB ok
57 Partially correct 47 ms 127940 KB partial
58 Correct 38 ms 127612 KB ok
59 Partially correct 37 ms 127572 KB partial
60 Partially correct 38 ms 127772 KB partial
61 Correct 38 ms 126036 KB ok
62 Correct 72 ms 130540 KB ok
63 Correct 78 ms 131264 KB ok
64 Correct 82 ms 131780 KB ok
65 Partially correct 1258 ms 529808 KB partial
66 Correct 785 ms 539204 KB ok
67 Correct 542 ms 506024 KB ok
68 Partially correct 502 ms 481288 KB partial
69 Partially correct 691 ms 491452 KB partial
70 Partially correct 847 ms 499492 KB partial
71 Partially correct 479 ms 480204 KB partial
72 Partially correct 456 ms 479424 KB partial
73 Correct 268 ms 40016 KB ok
74 Correct 258 ms 39976 KB ok
75 Correct 470 ms 479264 KB ok
76 Correct 748 ms 479548 KB ok
77 Correct 748 ms 479548 KB ok
78 Partially correct 539 ms 491908 KB partial
79 Correct 516 ms 484292 KB ok
80 Correct 512 ms 482756 KB ok
81 Partially correct 493 ms 482252 KB partial
82 Partially correct 531 ms 485316 KB partial
83 Partially correct 715 ms 503968 KB partial
84 Partially correct 478 ms 479312 KB partial
85 Correct 483 ms 479268 KB ok
86 Partially correct 478 ms 479528 KB partial
87 Partially correct 488 ms 480932 KB partial
88 Correct 487 ms 479280 KB ok
89 Partially correct 481 ms 479292 KB partial
90 Partially correct 484 ms 479376 KB partial
91 Partially correct 484 ms 479464 KB partial
92 Correct 585 ms 493936 KB ok
93 Correct 595 ms 496540 KB ok
94 Correct 526 ms 485524 KB ok
95 Correct 499 ms 482468 KB ok
96 Correct 483 ms 481452 KB ok
97 Correct 470 ms 480932 KB ok
98 Correct 482 ms 480152 KB ok
99 Correct 621 ms 494476 KB ok
100 Correct 1218 ms 560828 KB ok
101 Partially correct 539 ms 479524 KB partial
102 Partially correct 466 ms 479600 KB partial
103 Correct 1317 ms 577736 KB ok
104 Partially correct 468 ms 479852 KB partial
105 Partially correct 466 ms 479676 KB partial
106 Correct 1494 ms 587948 KB ok
107 Correct 1491 ms 587392 KB ok
108 Correct 507 ms 484800 KB ok
109 Correct 506 ms 483988 KB ok