oj.uz

답안 #948289

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
948289 2024-03-18T03:30:41 Z Nhoksocqt1 축구 경기장 (IOI23_soccer) C++17
77.5 / 100
 1227 ms 1485136 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 = 501;
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 dp[2][MAXM][MAXM][MAXM];
int sum[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;

                ii rec = max_rec[i][l][r];
                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 + 1 - (rec.se - rec.fi + 1)) * (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 + 1 - (rec.se - rec.fi + 1)) * (r - l));
                }

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

    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 <= 500)
        return sub5();

    return 1;
}

#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 2 ms 14684 KB ok

Subtask #1
6.0 / 6.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 2396 KB ok
2 Correct 1 ms 2500 KB ok
3 Correct 0 ms 2396 KB ok
4 Correct 1 ms 2396 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 2396 KB ok
7 Correct 2 ms 4700 KB ok
8 Correct 17 ms 7004 KB ok
9 Correct 239 ms 45652 KB ok

Subtask #2
8.0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 2396 KB ok
2 Correct 1 ms 2500 KB ok
3 Correct 1 ms 4444 KB ok
4 Correct 1 ms 4440 KB ok
5 Correct 1 ms 4444 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 4440 KB ok
8 Correct 1 ms 4696 KB ok
9 Correct 1 ms 4444 KB ok
10 Correct 1 ms 4700 KB ok
11 Correct 2 ms 4556 KB ok
12 Correct 1 ms 4444 KB ok
13 Correct 1 ms 4444 KB ok

Subtask #3
22.0 / 22.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 14684 KB ok
2 Correct 1 ms 2396 KB ok
3 Correct 1 ms 2500 KB ok
4 Correct 1 ms 4444 KB ok
5 Correct 1 ms 4440 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 4444 KB ok
8 Correct 1 ms 4440 KB ok
9 Correct 1 ms 4696 KB ok
10 Correct 1 ms 4444 KB ok
11 Correct 1 ms 4700 KB ok
12 Correct 2 ms 4556 KB ok
13 Correct 1 ms 4444 KB ok
14 Correct 1 ms 4444 KB ok
15 Correct 5 ms 18780 KB ok
16 Correct 3 ms 18920 KB ok
17 Correct 2 ms 18784 KB ok
18 Correct 3 ms 18780 KB ok
19 Correct 2 ms 18780 KB ok
20 Correct 1 ms 2392 KB ok
21 Correct 1 ms 2392 KB ok
22 Correct 3 ms 18780 KB ok
23 Correct 2 ms 18780 KB ok
24 Correct 2 ms 18780 KB ok
25 Correct 3 ms 18780 KB ok
26 Correct 3 ms 18780 KB ok

Subtask #4
18.0 / 18.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 14684 KB ok
2 Correct 1 ms 2396 KB ok
3 Correct 1 ms 2500 KB ok
4 Correct 0 ms 2396 KB ok
5 Correct 1 ms 2396 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 4440 KB ok
8 Correct 1 ms 4444 KB ok
9 Correct 1 ms 4444 KB ok
10 Correct 1 ms 4440 KB ok
11 Correct 1 ms 4696 KB ok
12 Correct 1 ms 4444 KB ok
13 Correct 1 ms 4700 KB ok
14 Correct 2 ms 4556 KB ok
15 Correct 1 ms 4444 KB ok
16 Correct 1 ms 4444 KB ok
17 Correct 5 ms 18780 KB ok
18 Correct 3 ms 18920 KB ok
19 Correct 2 ms 18784 KB ok
20 Correct 3 ms 18780 KB ok
21 Correct 2 ms 18780 KB ok
22 Correct 1 ms 2392 KB ok
23 Correct 1 ms 2392 KB ok
24 Correct 3 ms 18780 KB ok
25 Correct 2 ms 18780 KB ok
26 Correct 2 ms 18780 KB ok
27 Correct 3 ms 18780 KB ok
28 Correct 3 ms 18780 KB ok
29 Correct 2 ms 18780 KB ok
30 Correct 17 ms 64072 KB ok
31 Correct 7 ms 64088 KB ok
32 Correct 8 ms 64092 KB ok
33 Correct 7 ms 64092 KB ok
34 Correct 1 ms 2396 KB ok
35 Correct 1 ms 2504 KB ok
36 Correct 8 ms 64088 KB ok
37 Correct 7 ms 64092 KB ok
38 Correct 8 ms 64040 KB ok
39 Correct 7 ms 64092 KB ok
40 Correct 9 ms 64092 KB ok
41 Correct 8 ms 64136 KB ok

Subtask #5
16.0 / 16.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 14684 KB ok
2 Correct 1 ms 2396 KB ok
3 Correct 1 ms 2500 KB ok
4 Correct 0 ms 2396 KB ok
5 Correct 1 ms 2396 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 4440 KB ok
8 Correct 1 ms 4444 KB ok
9 Correct 1 ms 4444 KB ok
10 Correct 1 ms 4440 KB ok
11 Correct 1 ms 4696 KB ok
12 Correct 1 ms 4444 KB ok
13 Correct 1 ms 4700 KB ok
14 Correct 2 ms 4556 KB ok
15 Correct 1 ms 4444 KB ok
16 Correct 1 ms 4444 KB ok
17 Correct 5 ms 18780 KB ok
18 Correct 3 ms 18920 KB ok
19 Correct 2 ms 18784 KB ok
20 Correct 3 ms 18780 KB ok
21 Correct 2 ms 18780 KB ok
22 Correct 1 ms 2392 KB ok
23 Correct 1 ms 2392 KB ok
24 Correct 3 ms 18780 KB ok
25 Correct 2 ms 18780 KB ok
26 Correct 2 ms 18780 KB ok
27 Correct 3 ms 18780 KB ok
28 Correct 3 ms 18780 KB ok
29 Correct 2 ms 18780 KB ok
30 Correct 17 ms 64072 KB ok
31 Correct 7 ms 64088 KB ok
32 Correct 8 ms 64092 KB ok
33 Correct 7 ms 64092 KB ok
34 Correct 1 ms 2396 KB ok
35 Correct 1 ms 2504 KB ok
36 Correct 8 ms 64088 KB ok
37 Correct 7 ms 64092 KB ok
38 Correct 8 ms 64040 KB ok
39 Correct 7 ms 64092 KB ok
40 Correct 9 ms 64092 KB ok
41 Correct 8 ms 64136 KB ok
42 Correct 1227 ms 1484456 KB ok
43 Correct 996 ms 1484276 KB ok
44 Correct 1098 ms 1484040 KB ok
45 Correct 1122 ms 1484528 KB ok
46 Correct 1031 ms 1484132 KB ok
47 Correct 1041 ms 1484272 KB ok
48 Correct 23 ms 7004 KB ok
49 Correct 1108 ms 1484508 KB ok
50 Correct 1144 ms 1484072 KB ok
51 Correct 1059 ms 1485136 KB ok
52 Correct 1049 ms 1484188 KB ok
53 Correct 995 ms 1484188 KB ok
54 Correct 995 ms 1484276 KB ok
55 Correct 1028 ms 1484264 KB ok
56 Correct 990 ms 1484096 KB ok
57 Correct 1124 ms 1484188 KB ok
58 Correct 1131 ms 1484512 KB ok
59 Correct 1133 ms 1484396 KB ok

Subtask #6
7.5 / 30.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 14684 KB ok
2 Correct 1 ms 2396 KB ok
3 Correct 1 ms 2500 KB ok
4 Correct 0 ms 2396 KB ok
5 Correct 1 ms 2396 KB ok
6 Correct 1 ms 4444 KB ok
7 Correct 1 ms 2396 KB ok
8 Correct 2 ms 4700 KB ok
9 Correct 17 ms 7004 KB ok
10 Correct 239 ms 45652 KB ok
11 Correct 1 ms 4444 KB ok
12 Correct 1 ms 4440 KB ok
13 Correct 1 ms 4444 KB ok
14 Correct 1 ms 4444 KB ok
15 Correct 1 ms 4440 KB ok
16 Correct 1 ms 4696 KB ok
17 Correct 1 ms 4444 KB ok
18 Correct 1 ms 4700 KB ok
19 Correct 2 ms 4556 KB ok
20 Correct 1 ms 4444 KB ok
21 Correct 1 ms 4444 KB ok
22 Correct 5 ms 18780 KB ok
23 Correct 3 ms 18920 KB ok
24 Correct 2 ms 18784 KB ok
25 Correct 3 ms 18780 KB ok
26 Correct 2 ms 18780 KB ok
27 Correct 1 ms 2392 KB ok
28 Correct 1 ms 2392 KB ok
29 Correct 3 ms 18780 KB ok
30 Correct 2 ms 18780 KB ok
31 Correct 2 ms 18780 KB ok
32 Correct 3 ms 18780 KB ok
33 Correct 3 ms 18780 KB ok
34 Correct 2 ms 18780 KB ok
35 Correct 17 ms 64072 KB ok
36 Correct 7 ms 64088 KB ok
37 Correct 8 ms 64092 KB ok
38 Correct 7 ms 64092 KB ok
39 Correct 1 ms 2396 KB ok
40 Correct 1 ms 2504 KB ok
41 Correct 8 ms 64088 KB ok
42 Correct 7 ms 64092 KB ok
43 Correct 8 ms 64040 KB ok
44 Correct 7 ms 64092 KB ok
45 Correct 9 ms 64092 KB ok
46 Correct 8 ms 64136 KB ok
47 Correct 1227 ms 1484456 KB ok
48 Correct 996 ms 1484276 KB ok
49 Correct 1098 ms 1484040 KB ok
50 Correct 1122 ms 1484528 KB ok
51 Correct 1031 ms 1484132 KB ok
52 Correct 1041 ms 1484272 KB ok
53 Correct 23 ms 7004 KB ok
54 Correct 1108 ms 1484508 KB ok
55 Correct 1144 ms 1484072 KB ok
56 Correct 1059 ms 1485136 KB ok
57 Correct 1049 ms 1484188 KB ok
58 Correct 995 ms 1484188 KB ok
59 Correct 995 ms 1484276 KB ok
60 Correct 1028 ms 1484264 KB ok
61 Correct 990 ms 1484096 KB ok
62 Correct 1124 ms 1484188 KB ok
63 Correct 1131 ms 1484512 KB ok
64 Correct 1133 ms 1484396 KB ok
65 Partially correct 245 ms 45848 KB partial
66 Partially correct 250 ms 45664 KB partial
67 Partially correct 256 ms 45760 KB partial
68 Partially correct 257 ms 45860 KB partial
69 Partially correct 246 ms 45656 KB partial
70 Partially correct 242 ms 45776 KB partial
71 Partially correct 262 ms 45848 KB partial
72 Partially correct 239 ms 45908 KB partial
73 Correct 258 ms 46036 KB ok
74 Correct 248 ms 45904 KB ok
75 Partially correct 252 ms 45908 KB partial
76 Partially correct 247 ms 45720 KB partial
77 Partially correct 243 ms 45904 KB partial
78 Partially correct 288 ms 45652 KB partial
79 Partially correct 252 ms 45916 KB partial
80 Partially correct 242 ms 45760 KB partial
81 Partially correct 274 ms 45648 KB partial
82 Partially correct 278 ms 45728 KB partial
83 Partially correct 253 ms 45908 KB partial
84 Partially correct 265 ms 45908 KB partial
85 Partially correct 277 ms 45904 KB partial
86 Partially correct 260 ms 45740 KB partial
87 Partially correct 263 ms 45720 KB partial
88 Partially correct 260 ms 45844 KB partial
89 Partially correct 247 ms 46036 KB partial
90 Partially correct 249 ms 45904 KB partial
91 Partially correct 248 ms 45864 KB partial
92 Partially correct 248 ms 46072 KB partial
93 Partially correct 266 ms 45716 KB partial
94 Partially correct 245 ms 45864 KB partial
95 Partially correct 251 ms 45912 KB partial
96 Partially correct 243 ms 45652 KB partial
97 Partially correct 251 ms 45728 KB partial
98 Partially correct 242 ms 46060 KB partial
99 Partially correct 243 ms 45904 KB partial
100 Partially correct 243 ms 45840 KB partial
101 Partially correct 236 ms 45908 KB partial
102 Partially correct 238 ms 45904 KB partial
103 Partially correct 241 ms 45844 KB partial
104 Partially correct 239 ms 45732 KB partial
105 Partially correct 249 ms 45704 KB partial
106 Partially correct 240 ms 45908 KB partial
107 Partially correct 243 ms 45716 KB partial
108 Partially correct 247 ms 45652 KB partial
109 Partially correct 258 ms 38340 KB partial