oj.uz

Submission #572572

# Submission time Handle Problem Language Result Execution time Memory
572572 2022-06-04T17:19:27 Z model_code Flight to the Ford (BOI22_communication) C++17
30.3333 / 100
 5446 ms 2156 KB 
#include <vector>
#include "communication.h"

typedef long long ll;

using namespace std;

struct interval {
  ll l, r;
  interval(ll l, ll r) : l(l), r(r) {}
  bool contains(ll x) {
    return l <= x && x < r;
  }
  ll length() {
    return r - l;
  }
  interval shrink(ll o, ll s) {
    return interval(min(r, l + o), min(r, l + o + s));
  }
};

vector<interval> splitIntervals(vector<interval> c, ll o, ll s) {
  vector<interval> r;
  for (interval &it : c) {
    if (s > 0 && it.length() - o > 0)
      r.push_back(it.shrink(o, s));
    s -= max(0LL, min(s, it.length() - o));
    o -= min(o, it.length());
  }
  return r;
}

bool contains(vector<interval> c, ll x) {
  for (interval &it : c)
    if (it.contains(x))
      return true;
  return false;
}

struct state {
  ll s[2] = {0, 0};
  vector<vector<interval>> c;
  state(ll N): c(2) {
    s[1] = N;
    c[1].emplace_back(1, N + 1);
  }
  state(vector<vector<vector<interval>>> &cs): c(2) {
    for (int g = 0; g < 2; g++)
      for (vector<interval> &c : cs[g])
        add(g, c);
  }
  void add(int g, interval it) {
    s[g] += it.length();
    c[g].push_back(it);
  }
  void add(int g, vector<interval> &c) {
    for (interval &it : c)
      add(g, it);
  }
  vector<vector<vector<interval>>> split() {
    vector<vector<vector<interval>>> r(2);
    for (int g = 0; g < 2; g++) {
      int s1 = (s[g] + g) / 2, s2 = s[g] - s1;
      r[g].push_back(splitIntervals(c[g], 0, s1));
      r[g].push_back(splitIntervals(c[g], s1, s2));
    }
    return r;
  }
  ll size() {
    return s[0] + s[1];
  }
  vector<ll> remaining() {
    vector<ll> r;
    for (int g = 0; g < 2; g++)
      for (interval &it : c[g])
        for (ll v = it.l; v < it.r; v++)
          r.push_back(v);
    return r;
  }
};

std::pair<int, int> solve(int N, int X = -1) {
  state s(N);
  while (s.size() > 3) {
    vector<vector<vector<interval>>> c = s.split();
    int b = X != -1 ? send(contains(c[0][0], X) || contains(c[1][0], X)) : receive();
    c[0].erase(c[0].begin() + b);
    swap(c[0][0], c[1][b]);
    s = state(c);
  }
  vector<ll> r = s.remaining();
  if ((int) r.size() == 3) {
    int b1 = 1, b2;
    for (int i = 0; i < 2 && b1; i++)
      b1 = X != -1 ? send(r[0] == X || r[1] == X) : receive();
    if (!b1)
      b2 = X != -1 ? send(r[0] == X) : receive();
    r.erase(r.begin() + (b1 ? 2 : (b2 ? 1 : 0)));
  }
  return {r[0], r.back()};
}

void encode(int N, int X) {
  solve(N, X);
  for (int _=0;_<100;_++)send(1);
}

std::pair<int, int> decode(int N) {
  return solve(N);
}

Subtask #1
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 43 ms 1644 KB Output is correct
2 Correct 53 ms 1744 KB Output is correct
3 Correct 49 ms 1748 KB Output is correct
4 Correct 38 ms 1764 KB Output is correct
5 Correct 68 ms 1768 KB Output is correct
6 Correct 168 ms 1744 KB Output is correct
7 Correct 429 ms 1716 KB Output is correct

Subtask #2
15.33332 / 85.0

# Verdict Execution time Memory Grader output
1 Partially correct 981 ms 1672 KB Output is partially correct
2 Partially correct 559 ms 1732 KB Output is partially correct
3 Partially correct 579 ms 1744 KB Output is partially correct
4 Partially correct 1186 ms 1984 KB Output is partially correct
5 Partially correct 1030 ms 1752 KB Output is partially correct
6 Partially correct 832 ms 1760 KB Output is partially correct
7 Partially correct 3723 ms 1972 KB Output is partially correct
8 Partially correct 5446 ms 2156 KB Output is partially correct
9 Partially correct 5065 ms 1956 KB Output is partially correct
10 Partially correct 4769 ms 1984 KB Output is partially correct
11 Partially correct 4641 ms 2052 KB Output is partially correct
12 Partially correct 4636 ms 1992 KB Output is partially correct
13 Partially correct 4811 ms 2120 KB Output is partially correct
14 Partially correct 4821 ms 1936 KB Output is partially correct
15 Partially correct 2631 ms 1904 KB Output is partially correct
16 Partially correct 4810 ms 2020 KB Output is partially correct
17 Partially correct 1244 ms 2048 KB Output is partially correct
18 Partially correct 965 ms 1888 KB Output is partially correct
19 Partially correct 1007 ms 1788 KB Output is partially correct
20 Partially correct 1156 ms 1844 KB Output is partially correct
21 Partially correct 1071 ms 1932 KB Output is partially correct
22 Partially correct 1232 ms 1892 KB Output is partially correct
23 Partially correct 1849 ms 2008 KB Output is partially correct
24 Correct 48 ms 1692 KB Output is correct
25 Correct 89 ms 1680 KB Output is correct
26 Correct 99 ms 1780 KB Output is correct
27 Correct 41 ms 1784 KB Output is correct
28 Correct 77 ms 1712 KB Output is correct
29 Correct 157 ms 1700 KB Output is correct
30 Correct 363 ms 1724 KB Output is correct