Submission #623711

#	Time	Username	Problem	Language	Result	Execution time	Memory
623711		MohamedFaresNebili	Dungeons Game (IOI21_dungeons)	C++17	62 / 100	7061 ms	1553616 KiB

dungeons

#include <bits/stdc++.h>

            using namespace std;
            using ll = long long;

            ll N, D[400005], A[400005][30];
            ll B[400005][30], R[400005][30], M[400005][30];
            ll J[7][400005][30], C[7][400005][30];
            vector<ll> S, P, W, L, O;
            vector<ll> rev[400005];
            bool sameS = 1, isLess;

            long long solve(int i, int k) {
                if(i == N) return k;
                if(S[i] > k) return solve(L[i], k + P[i]);
                k += D[i];
                for(int l = 25; l >= 0; l--) {
                    if(M[i][l] <= k)
                        i = R[i][l];
                }
                i = R[i][0];
                if(i == N) return k;
                k -= D[i];
                return solve(L[i], k + P[i]);
            }
            long long query(ll i, ll k) {
                for(int l = 0; l < O.size(); l++) {
                    if(k >= O[l]) continue;
                    for(int j = 25; j >= 0; j--) {
                        if(k + C[l][i][j] < O[l]) {
                            k += C[l][i][j];
                            i = J[l][i][j];
                        }
                    }
                    k += C[l][i][0];
                    i = J[l][i][0];
                }
                return k;
            }

            void dfs(int v, int p) {
                for(auto u : rev[v]) {
                    D[u] = D[v] + S[u];
                    R[u][0] = v; M[u][0] = S[v] + D[v];
                    dfs(u, v);
                }
            }

            void init(int n, vector<int> s, vector<int> p,
                      vector<int> w, vector<int> l) {

                N = n; S.resize(n), P.resize(n);
                W.resize(n), L.resize(n);
                for(int i = 0; i < N; i++) {
                    S[i] = s[i], P[i] = p[i], W[i] = w[i], L[i] = l[i];
                    A[i][0] = L[i], B[i][0] = P[i];
                    sameS &= (S[i] == S[0]);
                    rev[W[i]].push_back(i); O.push_back(S[i]);
                }

                O.push_back(2e18); sort(O.begin(), O.end());
                O.erase(unique(O.begin(), O.end()), O.end());

                for(int l = 0; l < 7; l++)
                    for(int i = 0; i < 30; i++)
                        J[l][N][i] = N, C[l][N][i] = 0;

                A[N][0] = N; R[N][0] = N; L[N] = N; dfs(N, N);

                for(int i = 1; i < 30; i++)
                    for(int l = 0; l <= N; l++) {
                        A[l][i] = A[A[l][i - 1]][i - 1];
                        R[l][i] = R[R[l][i - 1]][i - 1];

                        B[l][i] = B[l][i - 1] + B[A[l][i - 1]][i - 1];
                        M[l][i] = max(M[l][i - 1], M[R[l][i - 1]][i - 1]);
                    }

                if(O.size() > 6) return;
                isLess = 1;

                for(int l = 0; l < O.size(); l++) {
                    for(int i = 0; i < 30; i++) {
                        for(int j = 0; j < N; j++) {
                            if(i > 0) {
                                J[l][j][i] = J[l][J[l][j][i - 1]][i - 1];
                                C[l][j][i] = C[l][j][i - 1] + C[l][J[l][j][i - 1]][i - 1];
                                continue;
                            }
                            if(S[j] >= O[l]) J[l][j][i] = L[j], C[l][j][i] = P[j];
                            else J[l][j][i] = W[j], C[l][j][i] = S[j];
                        }
                    }
                }
            }

            long long simulate(int x, int z) {
                if(isLess) return query(x, z);
                if(!sameS) return solve(x, z);
                ll res = z;
                for(int l = 25; l >= 0; l--)
                    if(res + B[x][l] < S[0]) {
                        res += B[x][l];
                        x = A[x][l];
                    }
                if(res >= S[0]) return res + D[x];
                res += P[x]; x = L[x]; res += D[x];
                return res;
            }

Compilation message (stderr)

dungeons.cpp: In function 'long long int query(ll, ll)':
dungeons.cpp:27:34: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   27 |                 for(int l = 0; l < O.size(); l++) {
      |                                ~~^~~~~~~~~~
dungeons.cpp: In function 'void init(int, std::vector<int>, std::vector<int>, std::vector<int>, std::vector<int>)':
dungeons.cpp:82:34: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   82 |                 for(int l = 0; l < O.size(); l++) {
      |                                ~~^~~~~~~~~~

• Subtask 1: 11 / 11
• Subtask 2: 26 / 26
• Subtask 3: 13 / 13
• Subtask 4: 12 / 12
• Subtask 5: 0 / 27
• Subtask 6: 0 / 11