oj.uz

Submission #573909

# Submission time Handle Problem Language Result Execution time Memory
573909 2022-06-07T12:00:09 Z lumibons Flight to the Ford (BOI22_communication) C++17
49 / 100
 5588 ms 2140 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 = 0;
  vector<interval> c;
  state() {}
  state(ll N): s(N) {
    c.emplace_back(1, N + 1);
  }
  state(vector<vector<interval>> &cs) {
    for (vector<interval> &c : cs)
      add(c);
  }
  void add(interval it) {
    s += it.length();
    c.push_back(it);
  }
  void add(vector<interval> &c) {
    for (interval &it : c)
      add(it);
  }
  vector<vector<interval>> split() {
    vector<vector<interval>> r;
    ll s1 = s / 4, s2 = (s - s1) / 3, s3 = (s - s1 - s2) / 2, s4 = s - s1 - s2 - s3;
    r.push_back(splitIntervals(c, 0, s1));
    r.push_back(splitIntervals(c, s1, s2));
    r.push_back(splitIntervals(c, s1 + s2, s3));
    r.push_back(splitIntervals(c, s1 + s2 + s3, s4));
    return r;
  }
  ll size() {
    return s;
  }
  vector<ll> remaining() {
    vector<ll> r;
    for (interval &it : c)
      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<interval>> c = s.split();
    int b1 = X != -1 ? send(contains(c[0], X) || contains(c[1], X)) : receive();
    int b2 = X != -1 ? send(contains(c[b1 ? 3 : 0], X)) : receive();
    c.erase(c.begin() + (b1 ? (b2 ? 2 : 3) : (b2 ? 1 : 0)));
    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);
}

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

Subtask #1
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1708 KB Output is correct
2 Correct 13 ms 1792 KB Output is correct
3 Correct 17 ms 1780 KB Output is correct
4 Correct 12 ms 1808 KB Output is correct
5 Correct 14 ms 1832 KB Output is correct
6 Correct 25 ms 1904 KB Output is correct
7 Correct 43 ms 1708 KB Output is correct

Subtask #2
34.0 / 85.0

# Verdict Execution time Memory Grader output
1 Partially correct 1210 ms 1796 KB Output is partially correct
2 Partially correct 498 ms 1792 KB Output is partially correct
3 Partially correct 681 ms 1796 KB Output is partially correct
4 Partially correct 1501 ms 1804 KB Output is partially correct
5 Partially correct 1081 ms 1952 KB Output is partially correct
6 Partially correct 1139 ms 1788 KB Output is partially correct
7 Partially correct 3631 ms 2048 KB Output is partially correct
8 Partially correct 5588 ms 2092 KB Output is partially correct
9 Partially correct 5112 ms 2040 KB Output is partially correct
10 Partially correct 4917 ms 2036 KB Output is partially correct
11 Partially correct 4750 ms 2140 KB Output is partially correct
12 Partially correct 4875 ms 2032 KB Output is partially correct
13 Partially correct 4825 ms 1936 KB Output is partially correct
14 Partially correct 4545 ms 1936 KB Output is partially correct
15 Partially correct 2180 ms 1784 KB Output is partially correct
16 Partially correct 4006 ms 1864 KB Output is partially correct
17 Partially correct 1170 ms 1864 KB Output is partially correct
18 Partially correct 950 ms 1792 KB Output is partially correct
19 Partially correct 1050 ms 1884 KB Output is partially correct
20 Partially correct 941 ms 1924 KB Output is partially correct
21 Partially correct 966 ms 1952 KB Output is partially correct
22 Partially correct 950 ms 1856 KB Output is partially correct
23 Partially correct 1858 ms 1896 KB Output is partially correct
24 Correct 11 ms 1700 KB Output is correct
25 Correct 9 ms 1880 KB Output is correct
26 Correct 11 ms 1772 KB Output is correct
27 Correct 7 ms 1672 KB Output is correct
28 Correct 11 ms 1600 KB Output is correct
29 Correct 17 ms 1716 KB Output is correct
30 Correct 31 ms 1656 KB Output is correct