oj.uz

Submission #912699

# Submission time Handle Problem Language Result Execution time Memory
912699 2024-01-19T18:09:56 Z Pentagonal Two Currencies (JOI23_currencies) C++17
100 / 100
 1645 ms 89236 KB 
// #pragma GCC target("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
//#pragma GCC -Wnarrowing

//Template {
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
 
//IO templates
//Note: use endl only for interactive problems or to debug segfaults; use newl for other problems
#define newl "\n"
#define fastIO ios::sync_with_stdio(false); cin.tie(nullptr)
#define fileIO(x) ifstream fin((str) x + (str) ".in"); ofstream fout((str) x + (str) ".out");
// void fileIO(string x) {}
#define flush() fflush(stdout)
#define interact(n) fflush(stdout); cin >> n; if (n == -1) return 0
#define testcases int tt; cin >> tt; fun (i, tt) solve();

#define edgeIO(m) fun (i, m) {int a, b; cin >> a >> b; addEdges(a, b);}
#define WeightedEdgeIO(m) fun (i, m) {int a, b, c; cin >> a >> b >> c; addWeightedEdges(a, b, c);}
#define numberedEdgeIO(m) fun (i, m) {int a, b; cin >> a >> b; addWeightedEdges(a, b, i);}
//types
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ordered_multiset tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ll long long
#define int long long
#define ld long double
#define str string
#define boolean bool
#define String string
 
//vector
#define pb push_back
#define append push_back
 
//pairs
#define mp make_pair
#define p2 pair<int, int>
#define p3 pair<int, p2>
#define m3(x, y, z) mp(x, mp(y, z))
#define ich first
#define ni second.first
#define sanshi second.second
 
//For loops
#define ahegao(i, a, b) for (int i = a; i < b; i++)
#define baka(i, b, a) for (int i = b; i > a; i--)
#define fun(i, n) for (int i = 1; i <= (n); (i)++)
#define fon(i, n) for (int i = 0; i < (n); (i)++)
#define fur(i, n) for (auto i : (n))
#define oniichan(i, n) for (auto &i : (n))
 
//Sorts
#define sz(aaa) ((signed) aaa.size())
// #define len(aaa) ((signed) aaa.size())
#define all(a) a.begin(), a.end()
#define Sort(a) sort((a).begin(), (a).end())
#define rSort(a) sort((a).rbegin(), (a).rend())
#define clamp(x, y) (x) = min((int) (x), (int) (y))
#define CLAMP(x, y) (x) = max((int) (x), (int) (y))
 
//Other stuff
#define pqueue priority_queue
#define elif else if
#define addEdges(a, b) adj[a].pb(b); adj[b].pb(a)
#define addWeightedEdges(a, b, c) adj[a].pb(mp(b, c)); adj[b].pb(mp(a, c))
// #define find find_by_order
#define printLength(x) if (x < INF) cout << x << newl; else cout << -1 << newl;
// #define printVector(a) fur (i, a) cout << i << ' '; cout << newl;
void printVector(vector<int> DontUseThisName) {
    fur (i, DontUseThisName) cout << i << ' '; cout << newl;
}
void printVector(vector<p2> DontUseThisName) {
    fur (i, DontUseThisName) cout << i.first << ' ' << i.second << newl; cout << newl;
}
void printVector(vector<vector<int>> DontUseThisName) {
    fur (i, DontUseThisName) printVector(i); cout << newl;
}
ll max(ll a, signed b) {return max(a, (ll) b);}
ll max(signed a, ll b) {return max((ll) a, b);}

void pv(int a) {cout << a << newl;}
void pv(int a, int b) {printVector({a, b});}
void pv(p2 a) {printVector({a.first, a.second});};
void pv(int a, int b, int c) {printVector({a, b, c});}
void pv(int a, int b, int c, int d) {printVector({a, b, c, d});}
void pv(int a, int b, int c, int d, int e) {printVector({a, b, c, d, e});}
void pv(int a, int b, int c, int d, int e, int f) {printVector({a, b, c, d, e, f});}
// void pv(int a, )
// void printVector(vector<char> DontUseThisName) {
//     fur (i, DontUseThisName) cout << i << ' '; cout << newl;
// }
// void printRange(vector<int>::iterator Left, vector<int>::iterator Right) {
//     for (auto i = Left; i < Right; i++) cout << *i << ' ';
//     cout << newl;
// } 
//Constants
const int MOD =  1e9+7; // 998244353
// const int SMALLMOD = 998244353;
const int INF = 2e9+1337;
const ll EXCEED = 2e18+1337;
const ll GRAVITY = 8e18;

//#define vectorIO(n, MikuBondage) fun (j, n) {int i; cin >> i; MikuBondage.pb(i);}
void vectorIO(int n, vector<int> &DontUseThisName) {
    fun (j, n) {int i; cin >> i; DontUseThisName.pb(i);}
}
//#define vector2IO(n, MikuBondage) fun (j, n) {int i, ii; cin >> i >> ii; MikuBondage.pb(mp(i, ii));}
void vector2IO(int n, vector<p2> &DontUseThisName) {
    fun (j, n) {int i, ii; cin >> i >> ii; DontUseThisName.pb(mp(i, ii));}
}

const int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
#define shortest_path_queue priority_queue<p2, vector<p2>, greater<p2>>
#define printArray(DontUseThisName, NakedLolisGalore, GenshinImpactClimbing) ahegao (j, NakedLolisGalore, GenshinImpactClimbing + 1) cout << DontUseThisName[j] << ' '; cout << newl;
#define print2dArray(SplitComplexProblemsIntoMultipleParts, ScuteSwarm, GenshinImpactClimbing) fun (i, ScuteSwarm) {fun (j, GenshinImpactClimbing) cout << SplitComplexProblemsIntoMultipleParts[i][j] << ' '; cout << newl;}
//}
// #define debugModifiedGraph
// #define debugLCA
// #define debugBIT
const int MAX = 200005;
vector<int> cost[MAX];
vector<p2> adj[MAX], adj2[MAX];
int pos[MAX], sparse[MAX][19], lower[MAX], upper[MAX], depth[MAX], weight[MAX], val[MAX], to[MAX], from[MAX], l[MAX], r[MAX], maxGold[MAX], maxSilver[MAX], res[MAX];
bool done[MAX];
vector<p2> ord, MikuBondage, lll;
int n, m, q, curr, temp;

void dfs1(int x, int from, int k) {
    pos[x] = k;
    fur (i, adj[x]) if (i.first != from) {
        if (cost[i.second].empty()) dfs1(i.first, x, k);
        else {
            curr += 1;
            adj2[k].pb({curr, i.second});
            adj2[curr].pb({k, i.second});
            dfs1(i.first, x, curr);
        }
    }
}

void dfs2(int x, int from, int dist) {
    temp++;
    depth[x] = dist;
    sparse[temp][0] = x;
    lower[x] = temp;
    fur (i, adj2[x]) if (i.first != from) {
        dfs2(i.first, x, dist + sz(cost[i.second]));
        
        fur (j, cost[i.second]) {
            ord.pb({j, i.first});
            #ifdef debugModifiedGraph
            weight[i.first] += j;
            #endif
        }
        temp++;
        sparse[temp][0] = x;
    }
    upper[x] = temp;
}

bool check(int a, int b) {
    return depth[a] < depth[b];
}

void buildSparseTable() {
    #ifdef debugLCA
    fun (i, temp) cout << sparse[i][0] << ' ';
    #endif
    fun (k, 18) {
        #ifdef debugLCA
        cout << newl;
        #endif
        fun (i, temp - (1 << k) + 1) {
            sparse[i][k] = min(sparse[i][k-1], sparse[i + (1 << (k - 1))][k-1], check);
            #ifdef debugLCA
            cout << sparse[i][k] << ' ';
            #endif
        }
    }
}

int lca(int l, int r) {
    
    #ifdef debugLCA
    pv(l, r, lower[l], lower[r]);
    #endif
    
    l = lower[l];
    r = lower[r];
    if (l > r) swap(l, r);
    int j = 1;
    while ((1 << j) < r - l + 1) j++;
    j--;
    
    return(min(sparse[l][j], sparse[r - (1 << j) + 1][j], check));
}

inline int query(int x) {
    if (x == 0) return 0;
    x = lower[x];
    int _curr = 0, _res = 0;
    baka (i, 18, -1) if (x & (1 << i)) {
        _curr += (1 << i);
        _res += val[_curr];
        // pv(curr, i, val[curr]);
    }
    return _res;
}

inline void modify(int x, int k) {
    int i = 0;
    while (x < MAX) {
        val[x] += k;
        // pv(x, k);
        // x = x - (x % (1 << i)) + (1 << i) * ;
        while ((x & (1 << i)) == 0) i++;
        x += (1 << i);
    }
}

signed main() {
    fastIO;
    cin >> n >> m >> q;
    numberedEdgeIO(n-1);
    fun (i, m) {
        int a, b; cin >> a >> b;
        cost[a].pb(b);
    }
    curr = 1;
    dfs1(1, -1, 1);
    // {
    dfs2(1, -1, 1);
    #ifdef debugModifiedGraph
    printArray(pos, 1, n);
    printArray(weight, 1, curr);
    printArray(depth, 1, curr);
    fun (i, curr) fur (j, adj2[i]) if (i < j.first) pv(i, j.first);
    #endif
    // }
    
    buildSparseTable();
    // {
    #ifdef debugLCA
    pv(lca(4, 5));
    #endif
    // }
    // printVector(ord);
    Sort(ord);
    fun (i, q) {
        cin >> to[i] >> from[i] >> maxGold[i] >> maxSilver[i];
        to[i] = pos[to[i]];
        from[i] = pos[from[i]];
        l[i] = 0;
        r[i] = sz(ord);
    }
    bool finished = false;
    while (not finished) {
        finished = true;
        fun (i, q) {
            if (not done[i]) {
                if (l[i] < r[i]) {
                    
                    int mid = (l[i] + r[i] + 1) / 2;
                    // pv(l[i], r[i], mid);
                    MikuBondage.pb({mid, i});
                    finished = false;
                } else {
                    // pv(i, l[i]);
                    lll.pb({l[i], i});
                    done[i] = true;
                }
            }
        }
        memset(val, 0, (temp + 2) * sizeof(int));
        Sort(MikuBondage);
        int pointer = 0;
        fur (rozalinBestWaifu, MikuBondage) {
            int t = rozalinBestWaifu.first;
            int i = rozalinBestWaifu.second;
            while (pointer < t) {
                modify(lower[ord[pointer].second], ord[pointer].first);
                modify(upper[ord[pointer].second] + 1, -ord[pointer].first);
                // {
                #ifdef debugBIT
                pv(ord[pointer]);
                pv(lower[ord[pointer].second], upper[ord[pointer].second]);
                printArray(val, 1, 16);
                #endif
                // }
                pointer++;
            }
            // pv(i, t, from[i], query(from[i]), to[i], query(to[i]));
            // pv(lca(from[i], to[i]), query(lca(from[i], to[i])), maxSilver[i]);
            if (query(from[i]) + query(to[i]) - 2 * query(lca(from[i], to[i])) <= maxSilver[i]) {
                l[i] = t;
            } else {
                r[i] = t - 1;
            }
        }
        // break;
        MikuBondage.clear();
    }
    memset(val, 0, (temp + 2) * sizeof(int));
    Sort(lll);
    int pointer = 0;
    fur (rozalinBestWaifu, lll) {
        int t = rozalinBestWaifu.first;
        int i = rozalinBestWaifu.second;
        while (pointer < t) {
            modify(lower[ord[pointer].second], 1);
            modify(upper[ord[pointer].second] + 1, -1);
            // {
            #ifdef debugBIT
            pv(ord[pointer]);
            pv(lower[ord[pointer].second], upper[ord[pointer].second]);
            printArray(val, 1, 16);
            #endif
            // }
            pointer++;
        }
        
        res[i] = max(maxGold[i] - depth[from[i]] - depth[to[i]] + 2 * depth[lca(from[i], to[i])]
        + (query(from[i]) + query(to[i]) - 2 * query(lca(from[i], to[i]))), -1);
    }
    fun (i, q) cout << res[i] << newl;

}

Compilation message

currencies.cpp: In function 'void printVector(std::vector<long long int>)':
currencies.cpp:54:19: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
   54 | #define fur(i, n) for (auto i : (n))
      |                   ^~~
currencies.cpp:75:5: note: in expansion of macro 'fur'
   75 |     fur (i, DontUseThisName) cout << i << ' '; cout << newl;
      |     ^~~
currencies.cpp:75:48: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
   75 |     fur (i, DontUseThisName) cout << i << ' '; cout << newl;
      |                                                ^~~~
currencies.cpp: In function 'void printVector(std::vector<std::pair<long long int, long long int> >)':
currencies.cpp:54:19: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
   54 | #define fur(i, n) for (auto i : (n))
      |                   ^~~
currencies.cpp:78:5: note: in expansion of macro 'fur'
   78 |     fur (i, DontUseThisName) cout << i.first << ' ' << i.second << newl; cout << newl;
      |     ^~~
currencies.cpp:78:74: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
   78 |     fur (i, DontUseThisName) cout << i.first << ' ' << i.second << newl; cout << newl;
      |                                                                          ^~~~
currencies.cpp: In function 'void printVector(std::vector<std::vector<long long int> >)':
currencies.cpp:54:19: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
   54 | #define fur(i, n) for (auto i : (n))
      |                   ^~~
currencies.cpp:81:5: note: in expansion of macro 'fur'
   81 |     fur (i, DontUseThisName) printVector(i); cout << newl;
      |     ^~~
currencies.cpp:81:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
   81 |     fur (i, DontUseThisName) printVector(i); cout << newl;
      |                                              ^~~~

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 37976 KB Output is correct
2 Correct 10 ms 37980 KB Output is correct
3 Correct 9 ms 37984 KB Output is correct
4 Correct 8 ms 37976 KB Output is correct
5 Correct 18 ms 38236 KB Output is correct
6 Correct 23 ms 38348 KB Output is correct
7 Correct 18 ms 38236 KB Output is correct
8 Correct 24 ms 38236 KB Output is correct
9 Correct 20 ms 38236 KB Output is correct
10 Correct 22 ms 38388 KB Output is correct
11 Correct 23 ms 38232 KB Output is correct
12 Correct 21 ms 38236 KB Output is correct
13 Correct 23 ms 38452 KB Output is correct
14 Correct 23 ms 38512 KB Output is correct
15 Correct 20 ms 38452 KB Output is correct
16 Correct 19 ms 38236 KB Output is correct
17 Correct 23 ms 38424 KB Output is correct
18 Correct 22 ms 38488 KB Output is correct
19 Correct 19 ms 38320 KB Output is correct
20 Correct 19 ms 38236 KB Output is correct
21 Correct 22 ms 38232 KB Output is correct
22 Correct 20 ms 38232 KB Output is correct
23 Correct 21 ms 38236 KB Output is correct
24 Correct 20 ms 38236 KB Output is correct
25 Correct 21 ms 38232 KB Output is correct
26 Correct 19 ms 38492 KB Output is correct
27 Correct 20 ms 38236 KB Output is correct
28 Correct 18 ms 38432 KB Output is correct
29 Correct 19 ms 38236 KB Output is correct
30 Correct 22 ms 38268 KB Output is correct
31 Correct 23 ms 38236 KB Output is correct
32 Correct 19 ms 38236 KB Output is correct
33 Correct 23 ms 38492 KB Output is correct
34 Correct 22 ms 38488 KB Output is correct
35 Correct 23 ms 38492 KB Output is correct

Subtask #2
28.0 / 28.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 37980 KB Output is correct
2 Correct 21 ms 38256 KB Output is correct
3 Correct 20 ms 38236 KB Output is correct
4 Correct 20 ms 38476 KB Output is correct
5 Correct 944 ms 73576 KB Output is correct
6 Correct 1295 ms 68672 KB Output is correct
7 Correct 1128 ms 68396 KB Output is correct
8 Correct 902 ms 67404 KB Output is correct
9 Correct 748 ms 66908 KB Output is correct
10 Correct 1523 ms 78212 KB Output is correct
11 Correct 1366 ms 78252 KB Output is correct
12 Correct 1340 ms 78440 KB Output is correct
13 Correct 1473 ms 78236 KB Output is correct
14 Correct 1214 ms 78396 KB Output is correct
15 Correct 1352 ms 88388 KB Output is correct
16 Correct 1645 ms 89060 KB Output is correct
17 Correct 1189 ms 87836 KB Output is correct
18 Correct 1393 ms 78280 KB Output is correct
19 Correct 1183 ms 78244 KB Output is correct
20 Correct 1369 ms 78572 KB Output is correct
21 Correct 1174 ms 76880 KB Output is correct
22 Correct 1100 ms 77080 KB Output is correct
23 Correct 1161 ms 77084 KB Output is correct
24 Correct 1182 ms 77064 KB Output is correct
25 Correct 981 ms 68692 KB Output is correct
26 Correct 942 ms 68836 KB Output is correct
27 Correct 940 ms 68616 KB Output is correct
28 Correct 645 ms 78068 KB Output is correct
29 Correct 625 ms 78132 KB Output is correct
30 Correct 742 ms 78288 KB Output is correct
31 Correct 753 ms 78612 KB Output is correct

Subtask #3
30.0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 37980 KB Output is correct
2 Correct 24 ms 38492 KB Output is correct
3 Correct 21 ms 38596 KB Output is correct
4 Correct 19 ms 38488 KB Output is correct
5 Correct 769 ms 76800 KB Output is correct
6 Correct 744 ms 74832 KB Output is correct
7 Correct 1087 ms 73288 KB Output is correct
8 Correct 1410 ms 89236 KB Output is correct
9 Correct 1317 ms 89232 KB Output is correct
10 Correct 1399 ms 89020 KB Output is correct
11 Correct 909 ms 79268 KB Output is correct
12 Correct 873 ms 79268 KB Output is correct
13 Correct 951 ms 79260 KB Output is correct
14 Correct 764 ms 89188 KB Output is correct
15 Correct 817 ms 88908 KB Output is correct
16 Correct 849 ms 89096 KB Output is correct
17 Correct 867 ms 89012 KB Output is correct

Subtask #4
32.0 / 32.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 37976 KB Output is correct
2 Correct 10 ms 37980 KB Output is correct
3 Correct 9 ms 37984 KB Output is correct
4 Correct 8 ms 37976 KB Output is correct
5 Correct 18 ms 38236 KB Output is correct
6 Correct 23 ms 38348 KB Output is correct
7 Correct 18 ms 38236 KB Output is correct
8 Correct 24 ms 38236 KB Output is correct
9 Correct 20 ms 38236 KB Output is correct
10 Correct 22 ms 38388 KB Output is correct
11 Correct 23 ms 38232 KB Output is correct
12 Correct 21 ms 38236 KB Output is correct
13 Correct 23 ms 38452 KB Output is correct
14 Correct 23 ms 38512 KB Output is correct
15 Correct 20 ms 38452 KB Output is correct
16 Correct 19 ms 38236 KB Output is correct
17 Correct 23 ms 38424 KB Output is correct
18 Correct 22 ms 38488 KB Output is correct
19 Correct 19 ms 38320 KB Output is correct
20 Correct 19 ms 38236 KB Output is correct
21 Correct 22 ms 38232 KB Output is correct
22 Correct 20 ms 38232 KB Output is correct
23 Correct 21 ms 38236 KB Output is correct
24 Correct 20 ms 38236 KB Output is correct
25 Correct 21 ms 38232 KB Output is correct
26 Correct 19 ms 38492 KB Output is correct
27 Correct 20 ms 38236 KB Output is correct
28 Correct 18 ms 38432 KB Output is correct
29 Correct 19 ms 38236 KB Output is correct
30 Correct 22 ms 38268 KB Output is correct
31 Correct 23 ms 38236 KB Output is correct
32 Correct 19 ms 38236 KB Output is correct
33 Correct 23 ms 38492 KB Output is correct
34 Correct 22 ms 38488 KB Output is correct
35 Correct 23 ms 38492 KB Output is correct
36 Correct 9 ms 37980 KB Output is correct
37 Correct 21 ms 38256 KB Output is correct
38 Correct 20 ms 38236 KB Output is correct
39 Correct 20 ms 38476 KB Output is correct
40 Correct 944 ms 73576 KB Output is correct
41 Correct 1295 ms 68672 KB Output is correct
42 Correct 1128 ms 68396 KB Output is correct
43 Correct 902 ms 67404 KB Output is correct
44 Correct 748 ms 66908 KB Output is correct
45 Correct 1523 ms 78212 KB Output is correct
46 Correct 1366 ms 78252 KB Output is correct
47 Correct 1340 ms 78440 KB Output is correct
48 Correct 1473 ms 78236 KB Output is correct
49 Correct 1214 ms 78396 KB Output is correct
50 Correct 1352 ms 88388 KB Output is correct
51 Correct 1645 ms 89060 KB Output is correct
52 Correct 1189 ms 87836 KB Output is correct
53 Correct 1393 ms 78280 KB Output is correct
54 Correct 1183 ms 78244 KB Output is correct
55 Correct 1369 ms 78572 KB Output is correct
56 Correct 1174 ms 76880 KB Output is correct
57 Correct 1100 ms 77080 KB Output is correct
58 Correct 1161 ms 77084 KB Output is correct
59 Correct 1182 ms 77064 KB Output is correct
60 Correct 981 ms 68692 KB Output is correct
61 Correct 942 ms 68836 KB Output is correct
62 Correct 940 ms 68616 KB Output is correct
63 Correct 645 ms 78068 KB Output is correct
64 Correct 625 ms 78132 KB Output is correct
65 Correct 742 ms 78288 KB Output is correct
66 Correct 753 ms 78612 KB Output is correct
67 Correct 9 ms 37980 KB Output is correct
68 Correct 24 ms 38492 KB Output is correct
69 Correct 21 ms 38596 KB Output is correct
70 Correct 19 ms 38488 KB Output is correct
71 Correct 769 ms 76800 KB Output is correct
72 Correct 744 ms 74832 KB Output is correct
73 Correct 1087 ms 73288 KB Output is correct
74 Correct 1410 ms 89236 KB Output is correct
75 Correct 1317 ms 89232 KB Output is correct
76 Correct 1399 ms 89020 KB Output is correct
77 Correct 909 ms 79268 KB Output is correct
78 Correct 873 ms 79268 KB Output is correct
79 Correct 951 ms 79260 KB Output is correct
80 Correct 764 ms 89188 KB Output is correct
81 Correct 817 ms 88908 KB Output is correct
82 Correct 849 ms 89096 KB Output is correct
83 Correct 867 ms 89012 KB Output is correct
84 Correct 900 ms 72532 KB Output is correct
85 Correct 908 ms 66608 KB Output is correct
86 Correct 741 ms 62908 KB Output is correct
87 Correct 1374 ms 78176 KB Output is correct
88 Correct 1351 ms 78200 KB Output is correct
89 Correct 1286 ms 78188 KB Output is correct
90 Correct 1403 ms 78568 KB Output is correct
91 Correct 1336 ms 78152 KB Output is correct
92 Correct 1450 ms 85104 KB Output is correct
93 Correct 1398 ms 87464 KB Output is correct
94 Correct 1347 ms 78500 KB Output is correct
95 Correct 1398 ms 78336 KB Output is correct
96 Correct 1333 ms 78360 KB Output is correct
97 Correct 1387 ms 78276 KB Output is correct
98 Correct 1102 ms 77172 KB Output is correct
99 Correct 1141 ms 76960 KB Output is correct
100 Correct 1137 ms 77100 KB Output is correct
101 Correct 1123 ms 77104 KB Output is correct
102 Correct 867 ms 68848 KB Output is correct
103 Correct 857 ms 68804 KB Output is correct
104 Correct 825 ms 68568 KB Output is correct
105 Correct 769 ms 78252 KB Output is correct
106 Correct 753 ms 78352 KB Output is correct
107 Correct 801 ms 78136 KB Output is correct
108 Correct 816 ms 78152 KB Output is correct