oj.uz

답안 #242494

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
242494 2020-06-27T21:38:12 Z rqi Ball Machine (BOI13_ballmachine) C++14
100 / 100
 279 ms 37104 KB 
#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef double db; 
typedef string str; 

typedef pair<int,int> pi;
typedef pair<ll,ll> pl; 
typedef pair<db,db> pd; 

typedef vector<int> vi; 
typedef vector<ll> vl; 
typedef vector<db> vd; 
typedef vector<str> vs; 
typedef vector<pi> vpi;
typedef vector<pl> vpl; 
typedef vector<pd> vpd; 

#define mp make_pair
#define f first
#define s second
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend() 
#define rsz resize
#define ins insert 
#define ft front() 
#define bk back()
#define pf push_front 
#define pb push_back
#define eb emplace_back 
#define lb lower_bound 
#define ub upper_bound 

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5; 
const ll INF = 1e18; 
const ld PI = acos((ld)-1);
const int xd[4] = {1,0,-1,0}, yd[4] = {0,1,0,-1}; 
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); 

template<class T> bool ckmin(T& a, const T& b) { 
    return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { 
    return a < b ? a = b, 1 : 0; } 
int pct(int x) { return __builtin_popcount(x); } 
int bits(int x) { return 31-__builtin_clz(x); } // floor(log2(x)) 
int cdiv(int a, int b) { return a/b+!(a<0||a%b == 0); } // division of a by b rounded up, assumes b > 0 
int fstTrue(function<bool(int)> f, int lo, int hi) {
    hi ++; assert(lo <= hi); // assuming f is increasing
    while (lo < hi) { // find first index such that f is true 
        int mid = (lo+hi)/2; 
        f(mid) ? hi = mid : lo = mid+1; 
    } 
    return lo;
}

// INPUT
template<class A> void re(complex<A>& c);
template<class A, class B> void re(pair<A,B>& p);
template<class A> void re(vector<A>& v);
template<class A, size_t SZ> void re(array<A,SZ>& a);

template<class T> void re(T& x) { cin >> x; }
void re(db& d) { str t; re(t); d = stod(t); }
void re(ld& d) { str t; re(t); d = stold(t); }
template<class H, class... T> void re(H& h, T&... t) { re(h); re(t...); }

template<class A> void re(complex<A>& c) { A a,b; re(a,b); c = {a,b}; }
template<class A, class B> void re(pair<A,B>& p) { re(p.f,p.s); }
template<class A> void re(vector<A>& x) { trav(a,x) re(a); }
template<class A, size_t SZ> void re(array<A,SZ>& x) { trav(a,x) re(a); }

// TO_STRING
#define ts to_string
str ts(char c) { return str(1,c); }
str ts(bool b) { return b ? "true" : "false"; }
str ts(const char* s) { return (str)s; }
str ts(str s) { return s; }
template<class A> str ts(complex<A> c) { 
    stringstream ss; ss << c; return ss.str(); }
str ts(vector<bool> v) { 
    str res = "{"; F0R(i,sz(v)) res += char('0'+v[i]);
    res += "}"; return res; }
template<size_t SZ> str ts(bitset<SZ> b) {
    str res = ""; F0R(i,SZ) res += char('0'+b[i]);
    return res; }
template<class A, class B> str ts(pair<A,B> p);
template<class T> str ts(T v) { // containers with begin(), end()
    bool fst = 1; str res = "{";
    for (const auto& x: v) {
        if (!fst) res += ", ";
        fst = 0; res += ts(x);
    }
    res += "}"; return res;
}
template<class A, class B> str ts(pair<A,B> p) {
    return "("+ts(p.f)+", "+ts(p.s)+")"; }

// OUTPUT
template<class A> void pr(A x) { cout << ts(x); }
template<class H, class... T> void pr(const H& h, const T&... t) { 
    pr(h); pr(t...); }
void ps() { pr("\n"); } // print w/ spaces
template<class H, class... T> void ps(const H& h, const T&... t) { 
    pr(h); if (sizeof...(t)) pr(" "); ps(t...); }

// DEBUG
void DBG() { cerr << "]" << endl; }
template<class H, class... T> void DBG(H h, T... t) {
    cerr << ts(h); if (sizeof...(t)) cerr << ", ";
    DBG(t...); }
#ifdef LOCAL // compile with -DLOCAL
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif

// FILE I/O
void setIn(string s) { freopen(s.c_str(),"r",stdin); }
void setOut(string s) { freopen(s.c_str(),"w",stdout); }
void unsyncIO() { ios_base::sync_with_stdio(0); cin.tie(0); }
void setIO(string s = "") {
    unsyncIO();
    // cin.exceptions(cin.failbit); 
    // throws exception when do smth illegal
    // ex. try to read letter into int
    if (sz(s)) { setIn(s+".in"), setOut(s+".out"); } // for USACO
}

const int mx = 100005;

int N, Q;
int R;
int postorder[mx];
int invpo[mx];

int origpar[mx];
vi origchildren[mx];
int minval[mx];

int curind;

int genMinVal(int node){
    int val = node;
    for(auto u: origchildren[node]){
        ckmin(val, genMinVal(u));
    }
    minval[node] = val;
    return val;
}

void genPO(int node){
    vpi c;
    for(auto u: origchildren[node]){
        c.pb(mp(minval[u], u));
    }
    sort(all(c));
    for(auto u: c){
        genPO(u.s);
    }
    postorder[node] = ++curind;
    invpo[curind] = node;
}

int par[30][mx];

set<int> empties;
bool filled[mx];

int main() {
    setIO();
    cin >> N >> Q;
    for(int i = 1; i <= N; i++){
        cin >> origpar[i];
        if(origpar[i] == 0) R = i;
        origchildren[origpar[i]].pb(i);
        empties.ins(i);
    }

    genMinVal(R);

    for(int i = 1; i <= N; i++){
        dbg(i, minval[i]);
    }

    genPO(R);

    // for(int i = 1; i <= N; i++){
    //     dbg(i, postorder[i], invpo[i]);
    // }


    for(int i = 1; i <= N; i++){
        par[0][postorder[i]] = postorder[origpar[i]];
    }

    for(int j = 1; j < 30; j++){
        for(int i = 1; i <= N; i++){
            par[j][i] = par[j-1][par[j-1][i]];
        }
    }

    for(int i = 1; i <= Q; i++){
        int typ;
        cin >> typ;
        if(typ == 1){
            int k;
            cin >> k;
            //dbg(i, k);
            int ans = 0;
            for(int j = 1; j <= k; j++){
                int ind = *(empties.begin());
                if(j == k) ans = ind;
                filled[ind] = 1;
                empties.erase(ind);
                //dbg(i, j, k, empties);
            }
            ps(invpo[ans]);
        }
        else{
            int x;
            cin >> x;
            //dbg(i, x);
            x = postorder[x];
            int ans = 0;
            for(int j = 29; j >= 0; j--){
                int newnode = par[j][x];
                if(filled[newnode] == 1){
                    x = newnode;
                    ans+=(1<<j);
                }
            }
            filled[x] = 0;
            empties.ins(x);
            ps(ans);
        }
        //dbg(i, empties);
    }

    // you should actually read the stuff at the bottom
}

/* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?)
    * do smth instead of nothing and stay organized
    * WRITE STUFF DOWN
*/

Compilation message

ballmachine.cpp: In function 'int main()':
ballmachine.cpp:192:26: warning: statement has no effect [-Wunused-value]
         dbg(i, minval[i]);
                          ^
ballmachine.cpp: In function 'void setIn(std::__cxx11::string)':
ballmachine.cpp:128:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
 void setIn(string s) { freopen(s.c_str(),"r",stdin); }
                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
ballmachine.cpp: In function 'void setOut(std::__cxx11::string)':
ballmachine.cpp:129:32: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
 void setOut(string s) { freopen(s.c_str(),"w",stdout); }
                         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
25.0 / 25.0

# 결과 실행 시간 메모리 Grader output
1 Correct 6 ms 2944 KB Output is correct
2 Correct 143 ms 15864 KB Output is correct
3 Correct 84 ms 16120 KB Output is correct
4 Correct 6 ms 2816 KB Output is correct
5 Correct 6 ms 2944 KB Output is correct
6 Correct 7 ms 3072 KB Output is correct
7 Correct 7 ms 3072 KB Output is correct
8 Correct 7 ms 3072 KB Output is correct
9 Correct 14 ms 3712 KB Output is correct
10 Correct 30 ms 6144 KB Output is correct
11 Correct 167 ms 15992 KB Output is correct
12 Correct 96 ms 16120 KB Output is correct
13 Correct 116 ms 15864 KB Output is correct

Subtask #2
30.0 / 30.0

# 결과 실행 시간 메모리 Grader output
1 Correct 52 ms 9336 KB Output is correct
2 Correct 206 ms 29432 KB Output is correct
3 Correct 111 ms 22552 KB Output is correct
4 Correct 85 ms 11000 KB Output is correct
5 Correct 86 ms 10892 KB Output is correct
6 Correct 77 ms 10872 KB Output is correct
7 Correct 81 ms 9448 KB Output is correct
8 Correct 52 ms 9336 KB Output is correct
9 Correct 166 ms 29564 KB Output is correct
10 Correct 185 ms 29304 KB Output is correct
11 Correct 166 ms 29220 KB Output is correct
12 Correct 204 ms 25720 KB Output is correct
13 Correct 142 ms 33016 KB Output is correct
14 Correct 105 ms 22500 KB Output is correct

Subtask #3
40.0 / 40.0

# 결과 실행 시간 메모리 Grader output
1 Correct 100 ms 16376 KB Output is correct
2 Correct 238 ms 26360 KB Output is correct
3 Correct 138 ms 30200 KB Output is correct
4 Correct 132 ms 24440 KB Output is correct
5 Correct 139 ms 24288 KB Output is correct
6 Correct 138 ms 24184 KB Output is correct
7 Correct 142 ms 21624 KB Output is correct
8 Correct 140 ms 30200 KB Output is correct
9 Correct 234 ms 29816 KB Output is correct
10 Correct 235 ms 29560 KB Output is correct
11 Correct 227 ms 29560 KB Output is correct
12 Correct 279 ms 26336 KB Output is correct
13 Correct 216 ms 37104 KB Output is correct
14 Correct 207 ms 22504 KB Output is correct

Subtask #4
5.0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 199 ms 29944 KB Output is correct
2 Correct 213 ms 26384 KB Output is correct
3 Correct 157 ms 36728 KB Output is correct
4 Correct 191 ms 29944 KB Output is correct
5 Correct 200 ms 29560 KB Output is correct
6 Correct 170 ms 29432 KB Output is correct
7 Correct 206 ms 26360 KB Output is correct
8 Correct 153 ms 36728 KB Output is correct
9 Correct 102 ms 22376 KB Output is correct