oj.uz

답안 #927192

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
927192 2024-02-14T11:32:14 Z GrindMachine 자동 인형 (IOI18_doll) C++17
71.553 / 100
 88 ms 14156 KB 
#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;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) (int)a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x,y) ((x+y-1)/(y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i,n) for(int i = 0; i < n; ++i)
#define rep1(i,n) for(int i = 1; i <= n; ++i)
#define rev(i,s,e) for(int i = s; i >= e; --i)
#define trav(i,a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a,b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a,b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(x) 42
#endif

/*



*/

const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

#include "doll.h"

void create_circuit(int m, std::vector<int> a) {
    // int N = A.size();
    // std::vector<int> C(M + 1);
    // C[0] = -1;
    // for (int i = 1; i <= M; ++i) {
    //     C[i] = 1;
    // }
    // std::vector<int> X(N), Y(N);
    // for (int k = 0; k < N; ++k) {
    //     X[k] = Y[k] = A[k];
    // }
    // answer(C, X, Y);

    int n = sz(a);
    a.pb(0);
    vector<int> b(m+1);
    b[0] = a[0];

    vector<int> pos[m+1];
    rep(i,n) pos[a[i]].pb(i);

    vector<int> sx(1), sy(1), leaf(1), flipped(1);
    int last_guy = inf1, last_type = inf1;

    vector<int> leave(m+1);

    rep1(x,m){
        int c = sz(pos[x]);
        if(c == 0) conts;

        int siz = 1;
        while(siz <= c) siz <<= 1;
        int chain_siz = __lg(siz);

        int root = sz(sx);
        b[x] = -root;

        rep1(i,chain_siz){
            sx.pb(0), sy.pb(0);
        }
        rep1(i,chain_siz-1){
            sx[root-1+i] = -root;
            sy[root-1+i] = -(root+i);
        }

        sx[root-1+chain_siz] = -root;
        sy[root-1+chain_siz] = 0;
        leave[x] = -(root-1+chain_siz);

        rev(bit,chain_siz-1,0){
            if(!(c&(1<<bit))) conts;
            if(!bit){
                while(sz(leaf) < sz(sx)){
                    leaf.pb(0);
                }
                leaf[root-1+chain_siz] = 1;
                conts;
            }

            // build bin tree, depth = bit-1
            int pos_on_chain = root-1+chain_siz-bit;
            int ptr = sz(sx);
            sx.pb(0), sy.pb(0);
            sx[pos_on_chain] = -ptr;
            queue<pii> q;
            q.push({ptr,0});

            while(!q.empty()){
                auto [u,d] = q.front();
                q.pop();

                if(d >= bit-1){
                    while(sz(leaf) < sz(sx)){
                        leaf.pb(0);
                    }
                    leaf[u] = 1;
                    conts;
                }

                sx[u] = -sz(sx);
                sy[u] = -(sz(sx)+1);

                sx.pb(0), sy.pb(0);
                sx.pb(0), sy.pb(0);

                q.push({-sx[u],d+1});
                q.push({-sy[u],d+1});
            }
        }

        while(sz(flipped) < sz(sx)){
            flipped.pb(0);
        }

        int ptr = root;
        int cnt = 0;

        while(ptr){
            if(leaf[ptr]){
                cnt++;
                if(cnt > c) break;
                flipped[ptr] ^= 1;
                int i = pos[x][cnt-1];
                int nxt = 0;
                if(i+1 < n) nxt = a[i+1];
                else{
                    last_guy = ptr;
                    last_type = flipped[ptr];
                }

                if(flipped[ptr]){
                    sx[ptr] = nxt;
                }
                else{
                    sy[ptr] = nxt;
                }

                ptr = root;

                if(cnt == c) break;
            }
            else{
                flipped[ptr] ^= 1;
                if(flipped[ptr]){
                    ptr = -sx[ptr];
                }
                else{
                    ptr = -sy[ptr];
                }
            }
        }
    }

    vector<pii> pending;
    rep1(i,m){
        if(!pos[i].empty()){
            pending.pb({b[i],leave[i]});
        }
    }

    pending.pb({0,0});

    if(last_type == 1){
        sx[last_guy] = pending[0].ff;
    }
    else{
        sy[last_guy] = pending[0].ff;
    }

    rep(i,sz(pending)-1){
        sy[-pending[i].ss] = pending[i+1].ff;
    }

    sx.erase(sx.begin());
    sy.erase(sy.begin());
    assert(sz(sx) <= 2*n);
    answer(b,sx,sy);
}

Subtask #1
2.0 / 2.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 348 KB Output is correct
2 Correct 30 ms 9784 KB Output is correct
3 Correct 27 ms 8660 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 9 ms 4188 KB Output is correct
6 Correct 44 ms 12240 KB Output is correct
7 Correct 0 ms 344 KB Output is correct

Subtask #2
0 / 4.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 348 KB Output is correct
2 Correct 30 ms 9784 KB Output is correct
3 Correct 27 ms 8660 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 9 ms 4188 KB Output is correct
6 Correct 44 ms 12240 KB Output is correct
7 Correct 0 ms 344 KB Output is correct
8 Incorrect 57 ms 13264 KB Output isn't correct
9 Halted 0 ms 0 KB -

Subtask #3
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 348 KB Output is correct
2 Correct 30 ms 9784 KB Output is correct
3 Correct 27 ms 8660 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 9 ms 4188 KB Output is correct
6 Correct 44 ms 12240 KB Output is correct
7 Correct 0 ms 344 KB Output is correct
8 Incorrect 57 ms 13264 KB Output isn't correct
9 Halted 0 ms 0 KB -

Subtask #4
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 0 ms 344 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 0 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 0 ms 344 KB Output is correct

Subtask #5
18.0 / 18.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 57 ms 6392 KB Output is correct
3 Correct 58 ms 6376 KB Output is correct
4 Correct 88 ms 9192 KB Output is correct

Subtask #6
41.5530038336 / 56.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 57 ms 6392 KB Output is correct
3 Correct 58 ms 6376 KB Output is correct
4 Correct 88 ms 9192 KB Output is correct
5 Partially correct 75 ms 14156 KB Output is partially correct
6 Partially correct 67 ms 13384 KB Output is partially correct
7 Partially correct 69 ms 13632 KB Output is partially correct
8 Partially correct 65 ms 12868 KB Output is partially correct
9 Partially correct 51 ms 6704 KB Output is partially correct
10 Partially correct 74 ms 12360 KB Output is partially correct
11 Partially correct 58 ms 10812 KB Output is partially correct
12 Partially correct 37 ms 7980 KB Output is partially correct
13 Partially correct 43 ms 9172 KB Output is partially correct
14 Partially correct 45 ms 9932 KB Output is partially correct
15 Partially correct 47 ms 10184 KB Output is partially correct
16 Partially correct 2 ms 604 KB Output is partially correct
17 Partially correct 35 ms 7736 KB Output is partially correct
18 Partially correct 37 ms 7636 KB Output is partially correct
19 Partially correct 35 ms 7640 KB Output is partially correct
20 Partially correct 54 ms 10560 KB Output is partially correct
21 Partially correct 58 ms 10560 KB Output is partially correct
22 Partially correct 52 ms 10052 KB Output is partially correct