oj.uz

Submission #971262

# Submission time Handle Problem Language Result Execution time Memory
971262 2024-04-28T09:20:37 Z aryanc403 The Big Prize (IOI17_prize) C++17
20 / 100
 51 ms 432 KB 
/*
  Compete against Yourself.
  Author - Aryan (@aryanc403)
*/
/*
  Credits -
  Atcoder library - https://atcoder.github.io/ac-library/production/document_en/ (namespace atcoder)
  Github source code of library - https://github.com/atcoder/ac-library/tree/master/atcoder
  https://codeforces.com/contest/4/submission/150120627
*/

#ifdef ARYANC403
    #include <header.h>
#else
    #pragma GCC optimize ("Ofast")
    // #pragma GCC target ("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
    #pragma GCC target ("sse,sse2,mmx")
    #pragma GCC optimize ("-ffloat-store")
    #include <bits/stdc++.h>
    #include <ext/pb_ds/assoc_container.hpp>
    #include <ext/pb_ds/tree_policy.hpp>
    #define dbg(args...) 42;
    #define endl "\n"
#endif

// y_combinator from @neal template https://codeforces.com/contest/1553/submission/123849801
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0200r0.html
template<class Fun> class y_combinator_result {
    Fun fun_;
public:
    template<class T> explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}
    template<class ...Args> decltype(auto) operator()(Args &&...args) { return fun_(std::ref(*this), std::forward<Args>(args)...); }
};
template<class Fun> decltype(auto) y_combinator(Fun &&fun) { return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun)); }

using namespace std;
#define fo(i,n)   for(i=0;i<(n);++i)
#define repA(i,j,n)   for(i=(j);i<=(n);++i)
#define repD(i,j,n)   for(i=(j);i>=(n);--i)
#define all(x) begin(x), end(x)
#define sz(x) ((lli)(x).size())
#define eb emplace_back
#define X first
#define Y second

using lli = long long int;
using mytype = long double;
using ii = pair<lli,lli>;
using vii = vector<ii>;
using vi = vector<lli>;

template <class T>
using ordered_set =  __gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// X.find_by_order(k) return kth element. 0 indexed.
// X.order_of_key(k) returns count of elements strictly less than k.

// namespace Re = std::ranges;
// namespace Ve = std::ranges::views;

const lli SEED=chrono::steady_clock::now().time_since_epoch().count();
mt19937_64 rng(SEED);
inline lli rnd(lli l,lli r)
{return uniform_int_distribution<lli>(l,r)(rng);}

int find_best(int n);
std::vector<int> ask(int i);

const lli LIM = 4000;

int find_best(int n){
    const vector<int> bst = {0,0};
    if(n<=LIM){
        for(lli i=0;i<n;i++){
            if(ask(i)==bst)
                return i;
        }
    }

    // map<lli,ii> dp;
    lli ans = -1;
    auto getVal = [&](const lli i)->ii{
        // if(dp.count(i))
        //     return dp[i];
        const auto res = ask(i);
        if(res==bst)
            ans=i;
        return {res[0],res[1]};
    };

    lli mxVal=0;
    for(lli it=0;it<100;it++){
        const lli v=rnd(0,n-1);
        const auto res=getVal(v);
        mxVal=max(mxVal,res.X+res.Y);
    }

    y_combinator([&](const auto &self,lli l,lli r)->void{
        if(ans!=-1)
            return;
        while(l<=r){
            const auto res=getVal(l);
            if(res.X+res.Y>=mxVal)
                break;
            l++;
        }

        while(l<=r){
            const auto res=getVal(r);
            if(res.X+res.Y>=mxVal)
                break;
            r--;
        }

        if(l>r)
            return;
        if(getVal(l).X==getVal(r).X)
            return;
        const lli mid = (l+r)/2;
        self(l,mid);
        self(mid,r);
    })(0,n-1);
    dbg(dp);
    assert(ans!=-1);
    return ans;
}

Compilation message

prize.cpp: In function 'int find_best(int)':
prize.cpp:22:26: warning: statement has no effect [-Wunused-value]
   22 |     #define dbg(args...) 42;
      |                          ^~
prize.cpp:122:5: note: in expansion of macro 'dbg'
  122 |     dbg(dp);
      |     ^~~

Subtask #1
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 344 KB Output is correct
3 Correct 1 ms 344 KB Output is correct
4 Correct 1 ms 344 KB Output is correct
5 Correct 1 ms 344 KB Output is correct
6 Correct 1 ms 344 KB Output is correct
7 Correct 2 ms 344 KB Output is correct
8 Correct 1 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 1 ms 344 KB Output is correct

Subtask #2
0 / 80.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 344 KB Output is correct
3 Correct 1 ms 344 KB Output is correct
4 Correct 1 ms 344 KB Output is correct
5 Correct 1 ms 344 KB Output is correct
6 Correct 1 ms 344 KB Output is correct
7 Correct 1 ms 344 KB Output is correct
8 Correct 3 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 1 ms 344 KB Output is correct
11 Correct 8 ms 432 KB Output is correct
12 Correct 1 ms 344 KB Output is correct
13 Correct 16 ms 420 KB Output is correct
14 Correct 7 ms 344 KB Output is correct
15 Correct 23 ms 432 KB Output is correct
16 Incorrect 51 ms 428 KB Incorrect
17 Halted 0 ms 0 KB -