oj.uz

Submission #627999

# Submission time Handle Problem Language Result Execution time Memory
627999 2022-08-13T02:56:51 Z Benq Rarest Insects (IOI22_insects) C++17
100 / 100
 56 ms 340 KB 
#include "insects.h"
 
#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python! 
 
// pairs
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
#define mp make_pair
#define f first
#define s second
 
#define tcT template<class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>; 
tcT, size_t SZ> using AR = array<T,SZ>; 
using vi = V<int>;
using vb = V<bool>;
using vl = V<ll>;
using vd = V<db>;
using vs = V<str>;
using vpi = V<pi>;
using vpl = V<pl>;
using vpd = V<pd>;
 
// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend() 
#define sor(x) sort(all(x)) 
#define rsz resize
#define ins insert 
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()
 
#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
tcT> int upb(V<T>& a, const T& b) { return int(ub(all(a),b)-bg(a)); }
 
// loops
#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 rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)
 
const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll BIG = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4]{1,0,-1,0}, dy[4]{0,1,0,-1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); 
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
 
// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
  return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x)) 
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }
 
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
 
tcT> bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0; } // set a = max(a,b)
 
tcTU> T fstTrue(T lo, T hi, U f) {
  ++hi; assert(lo <= hi); // assuming f is increasing
  while (lo < hi) { // find first index such that f is true 
    T mid = lo+(hi-lo)/2;
    f(mid) ? hi = mid : lo = mid+1; 
  } 
  return lo;
}
tcTU> T lstTrue(T lo, T hi, U f) {
  --lo; assert(lo <= hi); // assuming f is decreasing
  while (lo < hi) { // find first index such that f is true 
    T mid = lo+(hi-lo+1)/2;
    f(mid) ? lo = mid : hi = mid-1;
  } 
  return lo;
}
tcT> void remDup(vector<T>& v) { // sort and remove duplicates
  sort(all(v)); v.erase(unique(all(v)),end(v)); }
tcTU> void erase(T& t, const U& u) { // don't erase
  auto it = t.find(u); assert(it != end(t));
  t.erase(it); } // element that doesn't exist from (multi)set
 
#define tcTUU tcT, class ...U
 
inline namespace Helpers {
  //////////// is_iterable
  // https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
  // this gets used only when we can call begin() and end() on that type
  tcT, class = void> struct is_iterable : false_type {};
  tcT> struct is_iterable<T, void_t<decltype(begin(declval<T>())),
                                    decltype(end(declval<T>()))
                                   >
                         > : true_type {};
  tcT> constexpr bool is_iterable_v = is_iterable<T>::value;
 
  //////////// is_readable
  tcT, class = void> struct is_readable : false_type {};
  tcT> struct is_readable<T,
          typename std::enable_if_t<
              is_same_v<decltype(cin >> declval<T&>()), istream&>
          >
      > : true_type {};
  tcT> constexpr bool is_readable_v = is_readable<T>::value;
 
  //////////// is_printable
  // // https://nafe.es/posts/2020-02-29-is-printable/
  tcT, class = void> struct is_printable : false_type {};
  tcT> struct is_printable<T,
          typename std::enable_if_t<
              is_same_v<decltype(cout << declval<T>()), ostream&>
          >
      > : true_type {};
  tcT> constexpr bool is_printable_v = is_printable<T>::value;
}
 
inline namespace Input {
  tcT> constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
  tcTUU> void re(T& t, U&... u);
  tcTU> void re(pair<T,U>& p); // pairs
 
  // re: read
  tcT> typename enable_if<is_readable_v<T>,void>::type re(T& x) { cin >> x; } // default
  tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; } // complex
  tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i); // ex. vectors, arrays
  tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
  tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i) {
    each(x,i) re(x); }
  tcTUU> void re(T& t, U&... u) { re(t); re(u...); } // read multiple
 
  // rv: resize and read vectors
  void rv(size_t) {}
  tcTUU> void rv(size_t N, V<T>& t, U&... u);
  template<class...U> void rv(size_t, size_t N2, U&... u);
  tcTUU> void rv(size_t N, V<T>& t, U&... u) {
    t.rsz(N); re(t);
    rv(N,u...); }
  template<class...U> void rv(size_t, size_t N2, U&... u) {
    rv(N2,u...); }
 
  // dumb shortcuts to read in ints
  void decrement() {} // subtract one from each
  tcTUU> void decrement(T& t, U&... u) { --t; decrement(u...); }
  #define ints(...) int __VA_ARGS__; re(__VA_ARGS__);
  #define int1(...) ints(__VA_ARGS__); decrement(__VA_ARGS__);
}
 
inline namespace ToString {
  tcT> constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;
 
  // ts: string representation to print
  tcT> typename enable_if<is_printable_v<T>,str>::type ts(T v) {
    stringstream ss; ss << fixed << setprecision(15) << v;
    return ss.str(); } // default
  tcT> str bit_vec(T t) { // bit vector to string
    str res = "{"; F0R(i,sz(t)) res += ts(t[i]);
    res += "}"; return res; }
  str ts(V<bool> v) { return bit_vec(v); }
  template<size_t SZ> str ts(bitset<SZ> b) { return bit_vec(b); } // bit vector
  tcTU> str ts(pair<T,U> p); // pairs
  tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v); // vectors, arrays
  tcTU> str ts(pair<T,U> p) { return "("+ts(p.f)+", "+ts(p.s)+")"; }
  tcT> typename enable_if<is_iterable_v<T>,str>::type ts_sep(T v, str sep) {
    // convert container to string w/ separator sep
    bool fst = 1; str res = "";
    for (const auto& x: v) {
      if (!fst) res += sep;
      fst = 0; res += ts(x);
    }
    return res;
  }
  tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v) {
    return "{"+ts_sep(v,", ")+"}"; }
 
  // for nested DS
  template<int, class T> typename enable_if<!needs_output_v<T>,vs>::type 
    ts_lev(const T& v) { return {ts(v)}; }
  template<int lev, class T> typename enable_if<needs_output_v<T>,vs>::type 
    ts_lev(const T& v) {
    if (lev == 0 || !sz(v)) return {ts(v)};
    vs res;
    for (const auto& t: v) {
      if (sz(res)) res.bk += ",";
      vs tmp = ts_lev<lev-1>(t);
      res.ins(end(res),all(tmp));
    }
    F0R(i,sz(res)) {
      str bef = " "; if (i == 0) bef = "{";
      res[i] = bef+res[i];
    }
    res.bk += "}";
    return res;
  }
}
 
inline namespace Output {
  template<class T> void pr_sep(ostream& os, str, const T& t) { os << ts(t); }
  template<class T, class... U> void pr_sep(ostream& os, str sep, const T& t, const U&... u) {
    pr_sep(os,sep,t); os << sep; pr_sep(os,sep,u...); }
  // print w/ no spaces
  template<class ...T> void pr(const T&... t) { pr_sep(cout,"",t...); } 
  // print w/ spaces, end with newline
  void ps() { cout << "\n"; }
  template<class ...T> void ps(const T&... t) { pr_sep(cout," ",t...); ps(); } 
  // debug to cerr
  template<class ...T> void dbg_out(const T&... t) {
    pr_sep(cerr," | ",t...); cerr << endl; }
  void loc_info(int line, str names) {
    cerr << "Line(" << line << ") -> [" << names << "]: "; }
  template<int lev, class T> void dbgl_out(const T& t) {
    cerr << "\n\n" << ts_sep(ts_lev<lev>(t),"\n") << "\n" << endl; }
  #ifdef LOCAL
    #define dbg(...) loc_info(__LINE__,#__VA_ARGS__), dbg_out(__VA_ARGS__)
    #define dbgl(lev,x) loc_info(__LINE__,#x), dbgl_out<lev>(x)
  #else // don't actually submit with this
    #define dbg(...) 0
    #define dbgl(lev,x) 0
  #endif
 
  const clock_t beg = clock();
  #define dbg_time() dbg((db)(clock()-beg)/CLOCKS_PER_SEC)
}
 
inline namespace FileIO {
  void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
  void setOut(str s) { freopen(s.c_str(),"w",stdout); }
  void setIO(str s = "") {
    cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
    // 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 old USACO
  }
}
 
int cnum = 0;
 
void inside(int x) {
  dbg("INSIDE", x);
  move_inside(x); ++cnum;
}
 
void outside(int x) {
  dbg("OUTSIDE", x);
  move_outside(x); --cnum;
}
 
int min_cardinality(int N) {
  vi rem;
  F0R(i,N) {
    inside(i);
    if (press_button() > 1) outside(i), rem.pb(i);
  }
  int d = cnum;
  while (true) {
    shuffle(all(rem), rng);
    assert(cnum%d == 0);
    const int start = cnum/d;
    int hi = sz(rem)/d;
    if (hi == 0) return start;
    int mid = (hi+1)/2;
    vi a, b;
    int ind = 0;
    for (int x: rem) {
      inside(x);
      if (press_button() > start+mid) {
        outside(x);
        b.pb(x);
      } else {
        a.pb(x);
      }
      ++ind;
      if (sz(a) + sz(rem) - ind < d*mid) {
        if (sz(a) == d*mid - 1) return start + mid - 1;
        for (int y: a) outside(y);
        FOR(i, ind, sz(rem)) a.pb(rem[i]);
        break;
      } else if (sz(a) == d*mid) {
        FOR(i, ind, sz(rem)) b.pb(rem[i]);
        break;
      } else {
        assert(ind < sz(rem));
      }
    }
    if (sz(a) == d*mid) { // [mid, hi]
      rem = b;
    } else { // [lo, mid)
      rem = a;
    }
  }
}

Compilation message

insects.cpp: In function 'void inside(int)':
insects.cpp:237:22: warning: statement has no effect [-Wunused-value]
  237 |     #define dbg(...) 0
      |                      ^
insects.cpp:260:3: note: in expansion of macro 'dbg'
  260 |   dbg("INSIDE", x);
      |   ^~~
insects.cpp: In function 'void outside(int)':
insects.cpp:237:22: warning: statement has no effect [-Wunused-value]
  237 |     #define dbg(...) 0
      |                      ^
insects.cpp:265:3: note: in expansion of macro 'dbg'
  265 |   dbg("OUTSIDE", x);
      |   ^~~
insects.cpp: In function 'void FileIO::setIn(str)':
insects.cpp:246:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  246 |   void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
insects.cpp: In function 'void FileIO::setOut(str)':
insects.cpp:247:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  247 |   void setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 208 KB Output is correct
2 Correct 0 ms 208 KB Output is correct
3 Correct 0 ms 208 KB Output is correct
4 Correct 0 ms 208 KB Output is correct
5 Correct 1 ms 208 KB Output is correct
6 Correct 5 ms 304 KB Output is correct
7 Correct 2 ms 208 KB Output is correct
8 Correct 4 ms 208 KB Output is correct
9 Correct 3 ms 300 KB Output is correct
10 Correct 2 ms 300 KB Output is correct
11 Correct 2 ms 208 KB Output is correct
12 Correct 6 ms 208 KB Output is correct
13 Correct 6 ms 208 KB Output is correct
14 Correct 4 ms 208 KB Output is correct
15 Correct 6 ms 208 KB Output is correct
16 Correct 5 ms 208 KB Output is correct
17 Correct 6 ms 208 KB Output is correct
18 Correct 6 ms 208 KB Output is correct
19 Correct 8 ms 208 KB Output is correct
20 Correct 4 ms 308 KB Output is correct
21 Correct 4 ms 208 KB Output is correct
22 Correct 2 ms 208 KB Output is correct

Subtask #2
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 208 KB Output is correct
2 Correct 0 ms 208 KB Output is correct
3 Correct 0 ms 208 KB Output is correct
4 Correct 0 ms 208 KB Output is correct
5 Correct 1 ms 208 KB Output is correct
6 Correct 5 ms 304 KB Output is correct
7 Correct 2 ms 208 KB Output is correct
8 Correct 4 ms 208 KB Output is correct
9 Correct 3 ms 300 KB Output is correct
10 Correct 2 ms 300 KB Output is correct
11 Correct 2 ms 208 KB Output is correct
12 Correct 6 ms 208 KB Output is correct
13 Correct 6 ms 208 KB Output is correct
14 Correct 4 ms 208 KB Output is correct
15 Correct 6 ms 208 KB Output is correct
16 Correct 5 ms 208 KB Output is correct
17 Correct 6 ms 208 KB Output is correct
18 Correct 6 ms 208 KB Output is correct
19 Correct 8 ms 208 KB Output is correct
20 Correct 4 ms 308 KB Output is correct
21 Correct 4 ms 208 KB Output is correct
22 Correct 2 ms 208 KB Output is correct
23 Correct 18 ms 304 KB Output is correct
24 Correct 10 ms 208 KB Output is correct
25 Correct 23 ms 308 KB Output is correct
26 Correct 25 ms 312 KB Output is correct
27 Correct 15 ms 208 KB Output is correct
28 Correct 11 ms 208 KB Output is correct
29 Correct 13 ms 340 KB Output is correct
30 Correct 28 ms 208 KB Output is correct
31 Correct 17 ms 308 KB Output is correct
32 Correct 15 ms 304 KB Output is correct
33 Correct 16 ms 304 KB Output is correct
34 Correct 24 ms 208 KB Output is correct
35 Correct 22 ms 208 KB Output is correct
36 Correct 21 ms 304 KB Output is correct
37 Correct 18 ms 304 KB Output is correct
38 Correct 21 ms 292 KB Output is correct
39 Correct 19 ms 292 KB Output is correct
40 Correct 14 ms 332 KB Output is correct
41 Correct 9 ms 208 KB Output is correct

Subtask #3
75.0 / 75.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 208 KB Output is correct
2 Correct 1 ms 208 KB Output is correct
3 Correct 0 ms 208 KB Output is correct
4 Correct 0 ms 208 KB Output is correct
5 Correct 1 ms 208 KB Output is correct
6 Correct 1 ms 208 KB Output is correct
7 Correct 32 ms 308 KB Output is correct
8 Correct 14 ms 208 KB Output is correct
9 Correct 40 ms 316 KB Output is correct
10 Correct 56 ms 300 KB Output is correct
11 Correct 28 ms 304 KB Output is correct
12 Correct 16 ms 288 KB Output is correct
13 Correct 44 ms 304 KB Output is correct
14 Correct 31 ms 304 KB Output is correct
15 Correct 43 ms 300 KB Output is correct
16 Correct 44 ms 300 KB Output is correct
17 Correct 42 ms 312 KB Output is correct
18 Correct 48 ms 208 KB Output is correct
19 Correct 33 ms 304 KB Output is correct
20 Correct 38 ms 308 KB Output is correct
21 Correct 51 ms 308 KB Output is correct
22 Correct 40 ms 308 KB Output is correct
23 Correct 46 ms 300 KB Output is correct
24 Correct 31 ms 300 KB Output is correct
25 Correct 25 ms 296 KB Output is correct
26 Correct 20 ms 288 KB Output is correct
27 Correct 45 ms 340 KB Output is correct
28 Correct 46 ms 300 KB Output is correct
29 Correct 45 ms 304 KB Output is correct
30 Correct 21 ms 208 KB Output is correct
31 Correct 45 ms 308 KB Output is correct
32 Correct 56 ms 208 KB Output is correct
33 Correct 39 ms 300 KB Output is correct
34 Correct 56 ms 308 KB Output is correct
35 Correct 44 ms 308 KB Output is correct
36 Correct 42 ms 312 KB Output is correct
37 Correct 49 ms 304 KB Output is correct
38 Correct 42 ms 304 KB Output is correct
39 Correct 22 ms 296 KB Output is correct
40 Correct 31 ms 308 KB Output is correct
41 Correct 36 ms 308 KB Output is correct
42 Correct 40 ms 308 KB Output is correct
43 Correct 16 ms 208 KB Output is correct
44 Correct 20 ms 208 KB Output is correct
45 Correct 33 ms 308 KB Output is correct
46 Correct 21 ms 304 KB Output is correct
47 Correct 18 ms 292 KB Output is correct
48 Correct 20 ms 208 KB Output is correct