oj.uz

답안 #815631

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
815631 2023-08-08T17:37:05 Z skittles1412 던전 (IOI21_dungeons) C++17
100 / 100
 3985 ms 1591880 KB 
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx2")

#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using ll = long long;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

struct Dungeon {
    int s, p, w, l;
};

struct DS1 {
    struct Lift {
        int mn_esc, lose_d;
        long add;
    };

    static constexpr int LOGN = 25, BSIZE = 3;

    int n, kv;
    vector<Lift> lift[LOGN];

    DS1() {}
    void build(int _kv, const vector<Dungeon>& arr) {
        n = sz(arr);
        kv = _kv;

        for (auto& a : lift) {
            a.resize(n + 1);
        }

        int up_bound = kv == -1 ? 0 : 1 << (kv + 1);
        for (int i = 0; i < n; i++) {
            auto& [s, p, w, l] = arr[i];

            if (__lg(s) < kv || kv == -1) {
                lift[0][i] = {w == n ? 0 : max(0, up_bound - s), w, s};
                continue;
            } else if (__lg(s) > kv) {
                lift[0][i] = {l == n ? 0 : max(0, up_bound - p), l, p};
                continue;
            }

            lift[0][i] = {l == n ? 0 : max(0, min(s, up_bound - p)), l, p};
        }

        lift[0][n] = {0, n, 0};

        for (int it = 1; it < LOGN; it++) {
            for (int i = 0; i <= n; i++) {
                auto& ql = lift[it - 1][i];
                auto& qr = lift[it - 1][ql.lose_d];

                lift[it][i] = {
                    int(max(long(0), min(long(ql.mn_esc), qr.mn_esc - ql.add))),
                    qr.lose_d, ql.add + qr.add};
            }

            if (it % BSIZE == 0) {
                for (int i = it - BSIZE + 1; i < it; i++) {
                    vector<Lift>().swap(lift[i]);
                }
            }
        }
        for (int i = 0; i < LOGN; i++) {
            if (i % BSIZE) {
                vector<Lift>().swap(lift[i]);
            }
        }
    }

    void advance(int& u, long& w, const vector<Dungeon>& arr) {
        if (u == n || (kv != -1 && __lg(w) > kv)) {
            return;
        }
        // assert(__lg(w) == kv);

        for (int it = LOGN - 1; it >= 0; it--) {
            if (!sz(lift[it])) {
                continue;
            }

            for (int it2 = 0; it2 < (1 << BSIZE); it2++) {
                auto& cq = lift[it][u];

                if (kv != -1 && w >= cq.mn_esc) {
                    break;
                }

                u = cq.lose_d;
                w += cq.add;
                dbg(it, u, w);
            }
        }

        if (kv == -1) {
            assert(u == n);
            return;
        }

        dbg(kv, u, w);
        // assert(u != n && __lg(w) == kv);

        dbg(u, arr[u].s, arr[u].p);
        if (w >= arr[u].s) {
            w += arr[u].s;
            u = arr[u].w;
        } else {
            w += arr[u].p;
            u = arr[u].l;
        }

        // auto& cq = lift[0][u];

        // u = cq.win_d;
        // w += cq.win_add;

        dbg(u, w);
        // assert(u == n || __lg(w) > kv);
    }
};

struct Solver {
    static constexpr int LOGN = 25;

    int n;
    vector<Dungeon> arr;
    DS1 lift[LOGN], lift_last;

    Solver() {}
    void build(const vector<Dungeon>& _arr) {
        arr = _arr;
        n = sz(arr);

        for (int i = 0; i < LOGN; i++) {
            lift[i].build(i, arr);
        }
        lift_last.build(-1, arr);
    }

    long query(int u, long kv) {
        for (auto& a : lift) {
            a.advance(u, kv, arr);
        }
        lift_last.advance(u, kv, arr);

        assert(u == n);
        return kv;
    }
} solver;

void init(int n,
          vector<int> arr_s,
          vector<int> arr_p,
          vector<int> arr_w,
          vector<int> arr_l) {
    vector<Dungeon> arr;
    for (int i = 0; i < n; i++) {
        arr.push_back({arr_s[i], arr_p[i], arr_w[i], arr_l[i]});
    }

    solver.build(arr);
    dbg(&solver.arr);

    // size_t c = 0;
    // for (auto& a : solver.lift) {
    //     for (auto& b : a.lift) {
    //         if (sz(b) != b.capacity()) {
    //             cout << sz(b) << " " << b.capacity() << endl;
    //         }
    //         c += b.capacity() * sizeof(DS1::Lift);
    //     }
    // }
    // cout << (c >> 20) << endl;
    // exit(0);
}

ll simulate(int u, int kv) {
    dbg(&solver.arr);
    return solver.query(u, kv);
}

Subtask #1
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 340 KB Output is correct
3 Correct 7 ms 8276 KB Output is correct
4 Correct 202 ms 199092 KB Output is correct
5 Correct 10 ms 8184 KB Output is correct
6 Correct 196 ms 199200 KB Output is correct

Subtask #2
26.0 / 26.0

# 결과 실행 시간 메모리 Grader output
1 Correct 4 ms 4308 KB Output is correct
2 Correct 1912 ms 1591696 KB Output is correct
3 Correct 1777 ms 1591728 KB Output is correct
4 Correct 1881 ms 1591740 KB Output is correct
5 Correct 1731 ms 1591748 KB Output is correct
6 Correct 3196 ms 1591772 KB Output is correct
7 Correct 3016 ms 1591732 KB Output is correct

Subtask #3
13.0 / 13.0

# 결과 실행 시간 메모리 Grader output
1 Correct 6 ms 4308 KB Output is correct
2 Correct 261 ms 199964 KB Output is correct
3 Correct 261 ms 199884 KB Output is correct
4 Correct 256 ms 199948 KB Output is correct
5 Correct 232 ms 199876 KB Output is correct
6 Correct 526 ms 199976 KB Output is correct
7 Correct 633 ms 199888 KB Output is correct
8 Correct 798 ms 199972 KB Output is correct
9 Correct 232 ms 199988 KB Output is correct
10 Correct 643 ms 199984 KB Output is correct
11 Correct 1193 ms 199892 KB Output is correct
12 Correct 3956 ms 199876 KB Output is correct
13 Correct 2971 ms 199944 KB Output is correct

Subtask #4
12.0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 6 ms 4308 KB Output is correct
2 Correct 261 ms 199964 KB Output is correct
3 Correct 261 ms 199884 KB Output is correct
4 Correct 256 ms 199948 KB Output is correct
5 Correct 232 ms 199876 KB Output is correct
6 Correct 526 ms 199976 KB Output is correct
7 Correct 633 ms 199888 KB Output is correct
8 Correct 798 ms 199972 KB Output is correct
9 Correct 232 ms 199988 KB Output is correct
10 Correct 643 ms 199984 KB Output is correct
11 Correct 1193 ms 199892 KB Output is correct
12 Correct 3956 ms 199876 KB Output is correct
13 Correct 2971 ms 199944 KB Output is correct
14 Correct 5 ms 4308 KB Output is correct
15 Correct 233 ms 199872 KB Output is correct
16 Correct 243 ms 199888 KB Output is correct
17 Correct 382 ms 199872 KB Output is correct
18 Correct 328 ms 199892 KB Output is correct
19 Correct 500 ms 199976 KB Output is correct
20 Correct 457 ms 199876 KB Output is correct
21 Correct 633 ms 199944 KB Output is correct
22 Correct 849 ms 199908 KB Output is correct
23 Correct 1556 ms 199996 KB Output is correct
24 Correct 1901 ms 199940 KB Output is correct

Subtask #5
27.0 / 27.0

# 결과 실행 시간 메모리 Grader output
1 Correct 6 ms 4308 KB Output is correct
2 Correct 261 ms 199964 KB Output is correct
3 Correct 261 ms 199884 KB Output is correct
4 Correct 256 ms 199948 KB Output is correct
5 Correct 232 ms 199876 KB Output is correct
6 Correct 526 ms 199976 KB Output is correct
7 Correct 633 ms 199888 KB Output is correct
8 Correct 798 ms 199972 KB Output is correct
9 Correct 232 ms 199988 KB Output is correct
10 Correct 643 ms 199984 KB Output is correct
11 Correct 1193 ms 199892 KB Output is correct
12 Correct 3956 ms 199876 KB Output is correct
13 Correct 2971 ms 199944 KB Output is correct
14 Correct 5 ms 4308 KB Output is correct
15 Correct 233 ms 199872 KB Output is correct
16 Correct 243 ms 199888 KB Output is correct
17 Correct 382 ms 199872 KB Output is correct
18 Correct 328 ms 199892 KB Output is correct
19 Correct 500 ms 199976 KB Output is correct
20 Correct 457 ms 199876 KB Output is correct
21 Correct 633 ms 199944 KB Output is correct
22 Correct 849 ms 199908 KB Output is correct
23 Correct 1556 ms 199996 KB Output is correct
24 Correct 1901 ms 199940 KB Output is correct
25 Correct 215 ms 199112 KB Output is correct
26 Correct 306 ms 199960 KB Output is correct
27 Correct 235 ms 199904 KB Output is correct
28 Correct 235 ms 199868 KB Output is correct
29 Correct 280 ms 199972 KB Output is correct
30 Correct 505 ms 199928 KB Output is correct
31 Correct 614 ms 199868 KB Output is correct
32 Correct 871 ms 199996 KB Output is correct
33 Correct 556 ms 199864 KB Output is correct
34 Correct 1217 ms 199904 KB Output is correct
35 Correct 710 ms 199872 KB Output is correct

Subtask #6
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 4 ms 4308 KB Output is correct
2 Correct 1912 ms 1591696 KB Output is correct
3 Correct 1777 ms 1591728 KB Output is correct
4 Correct 1881 ms 1591740 KB Output is correct
5 Correct 1731 ms 1591748 KB Output is correct
6 Correct 3196 ms 1591772 KB Output is correct
7 Correct 3016 ms 1591732 KB Output is correct
8 Correct 6 ms 4308 KB Output is correct
9 Correct 261 ms 199964 KB Output is correct
10 Correct 261 ms 199884 KB Output is correct
11 Correct 256 ms 199948 KB Output is correct
12 Correct 232 ms 199876 KB Output is correct
13 Correct 526 ms 199976 KB Output is correct
14 Correct 633 ms 199888 KB Output is correct
15 Correct 798 ms 199972 KB Output is correct
16 Correct 232 ms 199988 KB Output is correct
17 Correct 643 ms 199984 KB Output is correct
18 Correct 1193 ms 199892 KB Output is correct
19 Correct 3956 ms 199876 KB Output is correct
20 Correct 2971 ms 199944 KB Output is correct
21 Correct 5 ms 4308 KB Output is correct
22 Correct 233 ms 199872 KB Output is correct
23 Correct 243 ms 199888 KB Output is correct
24 Correct 382 ms 199872 KB Output is correct
25 Correct 328 ms 199892 KB Output is correct
26 Correct 500 ms 199976 KB Output is correct
27 Correct 457 ms 199876 KB Output is correct
28 Correct 633 ms 199944 KB Output is correct
29 Correct 849 ms 199908 KB Output is correct
30 Correct 1556 ms 199996 KB Output is correct
31 Correct 1901 ms 199940 KB Output is correct
32 Correct 215 ms 199112 KB Output is correct
33 Correct 306 ms 199960 KB Output is correct
34 Correct 235 ms 199904 KB Output is correct
35 Correct 235 ms 199868 KB Output is correct
36 Correct 280 ms 199972 KB Output is correct
37 Correct 505 ms 199928 KB Output is correct
38 Correct 614 ms 199868 KB Output is correct
39 Correct 871 ms 199996 KB Output is correct
40 Correct 556 ms 199864 KB Output is correct
41 Correct 1217 ms 199904 KB Output is correct
42 Correct 710 ms 199872 KB Output is correct
43 Correct 1 ms 212 KB Output is correct
44 Correct 4 ms 4308 KB Output is correct
45 Correct 1886 ms 1591784 KB Output is correct
46 Correct 1654 ms 1591780 KB Output is correct
47 Correct 1620 ms 1591780 KB Output is correct
48 Correct 1623 ms 1591772 KB Output is correct
49 Correct 1883 ms 1591680 KB Output is correct
50 Correct 2285 ms 1591776 KB Output is correct
51 Correct 1581 ms 1591880 KB Output is correct
52 Correct 2506 ms 1591856 KB Output is correct
53 Correct 3577 ms 1591680 KB Output is correct
54 Correct 2520 ms 1591632 KB Output is correct
55 Correct 3985 ms 1591752 KB Output is correct
56 Correct 3038 ms 1591772 KB Output is correct
57 Correct 2980 ms 1591740 KB Output is correct
58 Correct 2948 ms 1591732 KB Output is correct
59 Correct 3193 ms 1591684 KB Output is correct
60 Correct 3835 ms 1591652 KB Output is correct
61 Correct 3480 ms 1591704 KB Output is correct