oj.uz

Submission #827845

# Submission time Handle Problem Language Result Execution time Memory
827845 2023-08-16T20:07:59 Z null_awe Maze (JOI23_ho_t3) C++14
43 / 100
 2000 ms 151464 KB 
#include <bits/stdc++.h>
using namespace std;

#define pii pair<int, int>

const int UNTIL = 69420;

vector<int> dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};

int LG2[UNTIL];

int csqrt[UNTIL], fsqrt[UNTIL];

void init() {
  LG2[1] = 0;
  for (int i = 2; i < UNTIL; ++i) LG2[i] = LG2[i >> 1] + 1;
  csqrt[1] = fsqrt[1] = 1;
  for (int i = 2; i < UNTIL; ++i) {
    fsqrt[i] = fsqrt[i - 1];
    while ((fsqrt[i] + 1) * (fsqrt[i] + 1) <= i) ++fsqrt[i];
    csqrt[i] = fsqrt[i];
    if (fsqrt[i] * fsqrt[i] < i) ++csqrt[i];
  }
}

struct VEB {

  int u, mn, mx, sz;
  VEB *summary;
  vector<VEB*> galaxy;

  inline int high(int k) { return k / sz; }
  inline int low(int k) { return k % sz; }
  inline int index(int k, int kk) { return k * sz + kk; }

  VEB(int u) : u(u) {
    mn = INT_MAX, mx = INT_MIN;
    if (u <= 2) summary = nullptr, galaxy.resize(0, nullptr);
    else {
      int ngalaxy = csqrt[u];
      sz = (u + ngalaxy - 1) / ngalaxy;
      summary = new VEB(ngalaxy);
      galaxy.resize(ngalaxy, nullptr);
      for (int i = 0; i < ngalaxy - 1; ++i) galaxy[i] = new VEB(sz);
      galaxy[ngalaxy - 1] = new VEB(u - (ngalaxy - 1) * sz);
    }
  }

  void insert(int x) {
    if (mn == INT_MAX) mn = mx = x;
    else {
      if (x < mn) swap(x, mn);
      if (x > mx) mx = x;
      if (u <= 2) return;
      int i = high(x), j = low(x);
      if (galaxy[i]->mn == INT_MAX) summary->insert(i);
      galaxy[i]->insert(j);
    }
  }

  void erase(int x) {
    // cout << "ERASING " << u << ' ' << x << endl;
    // if (u == 5 && x == 0) cout << mn << endl;
    if (u <= 2) {
      if (x != mx) mn = mx;
      else if (x == mn) mn = INT_MAX, mx = INT_MIN;
      else if (x == 0) mn = 1;
      else mx = 0;
      return;
    }
    if (x == mn) {
      // cout << "x == mn" << endl;
      int i = summary->mn;
      if (i == INT_MAX) {
        mn = INT_MAX, mx = INT_MIN;
        return;
      }
      // cout << i << endl;
      x = mn = index(i, galaxy[i]->mn);
      // cout << "x = " << mn << endl;
    }
    int i = high(x), j = low(x);
    // cout << i << ' ' << j << endl;
    galaxy[i]->erase(j);
    // if (galaxy[i]->u == 3) cout << galaxy[0]->mx << " asdfoaisdjflaksdjflaksdjf" << endl;
    if (galaxy[i]->mn == INT_MAX) summary->erase(i);
    if (x == mx) {
      if (summary->mx == INT_MIN) mx = mn;
      else {
        i = summary->mn;
        mx = index(i, galaxy[i]->mx);
        // if (u == 3) cout << "asfldahlsdkjfhalwieuhfoaiudhrgADFHGDFHGUDFHGADOFUHGADOFIUGHADUFGHADOUFGH " << mx << endl;
      }
    }
    // if (u == 5 && x == 0) exit(0);
  }

  int lower_bound(int x) {
    // cout << u << ' ' << x << ' ' << mn << endl;
    // if (u > 2) cout << "gmax " << galaxy[0]->mx << ' ' << galaxy[1]->mx << endl;
    if (x <= mn) return mn;
    if (u <= 2) {
      if (x <= mx) return mx;
      return INT_MAX;
    }
    int i = high(x), j = low(x);
    // cout << i << ' ' << j << endl;
    // cout << galaxy[i]->mx << endl;
    if (j <= galaxy[i]->mx) j = galaxy[i]->lower_bound(j);
    else {
      // cout << "qry other " << i + 1 << endl;
      i = summary->lower_bound(i + 1);
      j = galaxy[i]->mn;
    }
    // cout << "index(" << i << ", " << j << ")\n";
    return index(i, j);
  }
};

VEB* build_veb(int u) {
  VEB* root = new VEB(u);
  for (int i = 0; i < u; ++i) root->insert(i);
  return root;
}

struct Sustree2 {

  int n, m;
  vector<VEB*> has;

  Sustree2() {}

  Sustree2(int n, int m) : n(n), m(m), has(4 * n, nullptr) {}

  void build(int t, int tl, int tr) {
    // cout << "BUILD" << endl;
    has[t] = build_veb(m + 1);
    if (tl == tr) return;
    build(2 * t, tl, (tl + tr) / 2);
    build(2 * t + 1, (tl + tr) / 2 + 1, tr);
    // cout << "BUILT" << endl;
  }

  void build() {
    build(1, 0, n - 1);
  }

  void upd(int t, int tl, int tr, int p, int py) {
    if (tl == tr) {
      // cout << "UPD rng " << t << ' ' << tl << ' ' << tr << ' ' << p << ' ' << py << endl;
      // cout << tl << ' ' << tr << endl;
      has[t]->erase(py);
      // cout << "after max " << has[8]->summary->summary->mx << endl;
      return;
    }
    if (p <= (tl + tr) / 2) upd(2 * t, tl, (tl + tr) / 2, p, py);
    else upd(2 * t + 1, (tl + tr) / 2 + 1, tr, p, py);
    // cout << t << ' ' << tl << ' ' << tr << endl;
    // cout << "START a" << endl;
    int a = has[2 * t]->lower_bound(py);
    // cout << "START b " << endl;
    int b = has[2 * t + 1]->lower_bound(py);
    // cout << a << ' ' << b << ' ' << py << endl;
    if (a != py && b != py) {
      // cout << a << ' ' << b << ' ' << py << endl;
      // cout << "UPD rng " << t << ' ' << tl << ' ' << tr << ' ' << p << ' ' << py << endl;
      has[t]->erase(py);
      // cout << "after max " << has[8]->summary->summary->mx << endl;
    }
  }

  void upd(int x, int y) {
    // cout << "UPD " << x << ' ' << y << endl;
    // cout << "UPD " << x << ' ' << y << endl;
    upd(1, 0, n - 1, x, y);
    // cout << "DONE" << endl;
  }

  pii qry(int t, int tl, int tr, int l, int r, int lo, int hi) {
    l = max(l, tl), r = min(r, tr);
    if (l > r) return {-1, -1};
    if (tl == l && tr == r) {
      int gr = has[t]->lower_bound(lo);
      if (gr > hi) return {-1, -1};
      // cout << tl << ' ' << gr << endl;
      if (tl == tr) {
        return {tl, gr};
      }
    }
    int mm = (tl + tr) / 2;
    pii f = qry(2 * t, tl, mm, l, r, lo, hi);
    if (f.first >= 0) return f;
    return qry(2 * t + 1, mm + 1, tr, l, r, lo, hi);
  }

  pii qry(int x1, int y1, int x2, int y2) {
    // cout << "QRY" << endl;
    return qry(1, 0, n - 1, max(x1, 0), min(x2, n - 1), max(y1, 0), min(y2, m - 1));
  }
};

struct Sustree {

  int n, m;
  vector<set<int>> has;

  Sustree() {}

  Sustree(int n, int m) : n(n), m(m), has(4 * n) {}

  void build(int t, int tl, int tr) {
    set<int> cur;
    for (int j = 0; j < m; ++j) cur.insert(j);
    cur.insert(m);
    has[t] = cur;
    if (tl == tr) return;
    build(2 * t, tl, (tl + tr) / 2);
    build(2 * t + 1, (tl + tr) / 2 + 1, tr);
  }

  void build() {
    // cout << "BUILD ,;";
    build(1, 0, n - 1);
    // cout << "DONE" << endl;
  }

  void upd(int t, int tl, int tr, int p, int py) {
    // cout << t << ' ' <<  tl << ' ' << tr << endl;
    // for (int num : has[t]) cout << num << ' ';
    // cout << endl;
    if (tl == tr) {
      has[t].erase(py);
      return;
    }
    int m = (tl + tr) / 2;
    if (p <= m) upd(2 * t, tl, m, p, py);
    else upd(2 * t + 1, m + 1, tr, p, py);
    if (*has[2 * t].lower_bound(py) != py && *has[2 * t + 1].lower_bound(py) != py) has[t].erase(py);
  }

  void upd(int x, int y) {
    // cout << "UPD " << x << ' ' << y << endl;
    upd(1, 0, n - 1, x, y);
    // cout << "DONE" << endl;
  }

  pii qry(int t, int tl, int tr, int l, int r, int lo, int hi) {
    l = max(l, tl), r = min(r, tr);
    if (l > r) return {-1, -1};
    if (tl == l && tr == r) {
      int gr = *has[t].lower_bound(lo);
      if (gr > hi) return {-1, -1};
      if (tl == tr) {
        return {tl, gr};
      }
      int m = (tl + tr) / 2;
      if (*has[2 * t].lower_bound(lo) <= hi) return qry(2 * t, tl, m, l, r, lo, hi);
      return qry(2 * t + 1, m + 1, tr, l, r, lo, hi);
    }
    int m = (tl + tr) / 2;
    pii f = qry(2 * t, tl, m, l, r, lo, hi);
    if (f.first >= 0) return f;
    return qry(2 * t + 1, m + 1, tr, l, r, lo, hi);
  }

  pii qry(int x1, int y1, int x2, int y2) {
    return qry(1, 0, n - 1, max(x1, 0), min(x2, n - 1), max(y1, 0), min(y2, m - 1));
  }
};

struct Segtree {

  int n;
  vector<bool> on;

  Segtree() {}

  Segtree(int n) : n(n), on(4 * n, 1) {}

  void upd(int t, int tl, int tr, int p) {
    if (tl == tr) on[t] = false;
    else {
      int m = (tl + tr) / 2;
      if (p <= m) upd(2 * t, tl, m, p);
      else upd(2 * t + 1, m + 1, tr, p);
      on[t] = on[2 * t] | on[2 * t + 1];
    }
  }

  int qry(int t, int tl, int tr, int l, int r) {
    l = max(l, tl), r = min(r, tr);
    if (l > r) return -1;
    if (tl == l && tr == r && !on[t]) return -1;
    if (tl == tr) {
      assert(on[t]);
      return tl;
    }
    int m = (tl + tr) / 2;
    int f = qry(2 * t, tl, m, l, r);
    if (f >= 0) return f;
    return qry(2 * t + 1, m + 1, tr, l, r);
  }
};

struct Groups {

  int r, c;
  vector<Segtree> rs, cs;

  Groups() {}

  Groups(int r, int c) : r(r), c(c) {
    for (int i = 0; i < r; ++i) {
      Segtree tmp(c);
      rs.push_back(tmp);
    }
    for (int i = 0; i < c; ++i) {
      Segtree tmp(r);
      cs.push_back(tmp);
    }
  }

  void upd(int x, int y) {
    // cout << x << ' ' << y << endl;
    rs[x].upd(1, 0, c - 1, y);
    cs[y].upd(1, 0, r - 1, x);
    // cout << "done" << endl;
  }

  int qrow(int row, int l, int rr) {
    if (row < 0 || row >= r) return -1;
    return rs[row].qry(1, 0, c - 1, max(l, 0), min(rr, c - 1));
  }

  int qcol(int col, int l, int rr) {
    if (col < 0 || col >= c) return -1;
    return cs[col].qry(1, 0, r - 1, max(l, 0), min(rr, r - 1));
  }
};

int main() {
  init();
  ios_base::sync_with_stdio(false); cin.tie(NULL);
  int r, c, n; cin >> r >> c >> n;
  int sx, sy; cin >> sx >> sy; --sx, --sy;
  int gx, gy; cin >> gx >> gy; --gx, --gy;
  vector<string> arr(r);
  for (int i = 0; i < r; ++i) cin >> arr[i];
  // . = empty
  // # = wall
  Sustree sus(r, c); sus.build();
  Groups groups(r, c);
  vector<vector<int>> dists(r, vector<int>(c, INT_MAX));
  dists[sx][sy] = 0;
  // cout << dists[gx][gy] << '\n';
  groups.upd(sx, sy);
  sus.upd(sx, sy);
  // cout << groups.qrow(sx, sy, sy) << endl;
  vector<pii> q; q.push_back({sx, sy});
  queue<pii> rq; for (pii _p : q) rq.push(_p);
  while (rq.size()) {
    pii front = rq.front(); rq.pop();
    int xx = front.first, yy = front.second;
    for (int d = 0; d < 4; ++d) {
      int nx = xx + dx[d], ny = yy + dy[d];
      if (nx < 0 || ny < 0 || nx >= r || ny >= c) continue;
      if (dists[nx][ny] < INT_MAX || arr[nx][ny] == '#') continue;
      rq.push({nx, ny});
      q.push_back({nx, ny});
      dists[nx][ny] = dists[xx][yy];
      groups.upd(nx, ny);
      sus.upd(nx, ny);
    }
  }
  while (q.size()) {
    // for (int i = 0; i < r; ++i) {
      // for (int j = 0; j < c; ++j) cout << dists[i][j] << ' ';
      // cout << endl;
    // }
    // break;
    // cout << "here" << endl;
    // break;
    vector<pii> nq;
    for (pii p : q) {
      int x = p.first, y = p.second;
      // cout << x << ' ' << y << '\n';
      if (x > 0 && dists[x - 1][y] <= dists[x][y]) {
          // cout << "t1" << endl;
        // query down:
        int cur;
        while ((cur = groups.qrow(x + n, y - n + 1, y + n - 1)) != -1) {
          nq.push_back({x + n, cur});
          dists[x + n][cur] = dists[x][y] + 1;
          groups.upd(x + n, cur);
          sus.upd(x + n, cur);
        }
        if (x + n - 1 < r && y - n >= 0 && dists[x + n - 1][y - n] == INT_MAX) {
          nq.push_back({x + n - 1, y - n});
          dists[x + n - 1][y - n] = dists[x][y] + 1;
          groups.upd(x + n - 1, y - n);
          sus.upd(x + n - 1, y - n);
        }
        if (x + n - 1 < r && y + n < c && dists[x + n - 1][y + n] == INT_MAX) {
          nq.push_back({x + n - 1, y + n});
          dists[x + n - 1][y + n] = dists[x][y] + 1;
          groups.upd(x + n - 1, y + n);
          sus.upd(x + n - 1, y + n);
        }
      } else if (y < r - 1 && dists[x][y + 1] <= dists[x][y]) {
          // cout << "t4" << endl;
        // query left:
        int cur;
        while ((cur = groups.qcol(y - n, x - n + 1, x + n - 1)) != -1) {
          nq.push_back({cur, y - n});
          dists[cur][y - n] = dists[x][y] + 1;
          groups.upd(cur, y - n);
          sus.upd(cur, y - n);
        }
        if (y - n + 1 >= 0 && x - n >= 0 && dists[x - n][y - n + 1] == INT_MAX) {
          nq.push_back({x - n, y - n + 1});
          dists[x - n][y - n + 1] = dists[x][y] + 1;
          groups.upd(x - n, y - n + 1);
          sus.upd(x - n, y - n + 1);
        }
        if (y - n + 1 >= 0 && x + n < r && dists[x + n][y - n + 1] == INT_MAX) {
          nq.push_back({x + n, y - n + 1});
          dists[x + n][y - n + 1] = dists[x][y] + 1;
          groups.upd(x + n, y - n + 1);
          sus.upd(x + n, y - n + 1);
        }
      } else {
        // query all:
        for (int i = -n; i <= n; i += 2 * n) {
          int cx = x + i, cyl = y - n + 1, cyr = y + n - 1, cur;
          while ((cur = groups.qrow(cx, cyl, cyr)) != -1) {
            nq.push_back({cx, cur});
            dists[cx][cur] = dists[x][y] + 1;
            groups.upd(cx, cur);
            sus.upd(cx, cur);
          }
        }
        pii cur;
        while ((cur = sus.qry(x - n + 1, y - n, x + n - 1, y + n)).first != -1) {
          int nx = cur.first, ny = cur.second;
          nq.push_back({nx, ny});
          dists[nx][ny] = dists[x][y] + 1;
          groups.upd(nx, ny);
          sus.upd(nx, ny);
        }
      }
    }
    queue<pii> rq; for (pii _p : nq) rq.push(_p);
    while (rq.size()) {
      pii front = rq.front(); rq.pop();
      int xx = front.first, yy = front.second;
      for (int d = 0; d < 4; ++d) {
        int nx = xx + dx[d], ny = yy + dy[d];
        if (nx < 0 || ny < 0 || nx >= r || ny >= c) continue;
        if (dists[nx][ny] < INT_MAX || arr[nx][ny] == '#') continue;
        rq.push({nx, ny});
        nq.push_back({nx, ny});
        dists[nx][ny] = dists[xx][yy];
        groups.upd(nx, ny);
        sus.upd(nx, ny);
      }
    }
    q = nq;
  }
  cout << dists[gx][gy] << '\n';
  return 0;
}

Compilation message

Main.cpp:12:5: warning: built-in function 'csqrt' declared as non-function [-Wbuiltin-declaration-mismatch]
   12 | int csqrt[UNTIL], fsqrt[UNTIL];
      |     ^~~~~

Subtask #1
0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 1 ms 1108 KB Output is correct
3 Correct 1 ms 1236 KB Output is correct
4 Correct 1 ms 1236 KB Output is correct
5 Correct 2 ms 1236 KB Output is correct
6 Correct 2 ms 1236 KB Output is correct
7 Correct 1 ms 1236 KB Output is correct
8 Correct 2 ms 1236 KB Output is correct
9 Correct 1 ms 1108 KB Output is correct
10 Correct 1 ms 1108 KB Output is correct
11 Correct 1 ms 1108 KB Output is correct
12 Correct 1 ms 1108 KB Output is correct
13 Correct 1 ms 1108 KB Output is correct
14 Correct 1 ms 1108 KB Output is correct
15 Correct 1 ms 1108 KB Output is correct
16 Correct 2 ms 1236 KB Output is correct
17 Correct 1 ms 1236 KB Output is correct
18 Correct 2 ms 1236 KB Output is correct
19 Correct 72 ms 7108 KB Output is correct
20 Correct 26 ms 8556 KB Output is correct
21 Correct 59 ms 7848 KB Output is correct
22 Correct 71 ms 7264 KB Output is correct
23 Correct 63 ms 7224 KB Output is correct
24 Correct 29 ms 9812 KB Output is correct
25 Correct 35 ms 9884 KB Output is correct
26 Correct 74 ms 7520 KB Output is correct
27 Correct 77 ms 7252 KB Output is correct
28 Correct 57 ms 7136 KB Output is correct
29 Correct 217 ms 16200 KB Output is correct
30 Correct 44 ms 9788 KB Output is correct
31 Correct 183 ms 18368 KB Output is correct
32 Correct 207 ms 16384 KB Output is correct
33 Correct 202 ms 16288 KB Output is correct
34 Correct 79 ms 27624 KB Output is correct
35 Correct 89 ms 27672 KB Output is correct
36 Correct 218 ms 16768 KB Output is correct
37 Correct 228 ms 16520 KB Output is correct
38 Correct 167 ms 16212 KB Output is correct
39 Execution timed out 2085 ms 151464 KB Time limit exceeded
40 Halted 0 ms 0 KB -

Subtask #2
19.0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 2 ms 1108 KB Output is correct
3 Correct 1 ms 1108 KB Output is correct
4 Correct 2 ms 1108 KB Output is correct
5 Correct 1 ms 1236 KB Output is correct
6 Correct 1 ms 1108 KB Output is correct
7 Correct 1 ms 1108 KB Output is correct
8 Correct 1 ms 1108 KB Output is correct
9 Correct 6 ms 1236 KB Output is correct
10 Correct 2 ms 1236 KB Output is correct
11 Correct 1 ms 1236 KB Output is correct
12 Correct 2 ms 1236 KB Output is correct
13 Correct 1 ms 1236 KB Output is correct
14 Correct 1 ms 1236 KB Output is correct
15 Correct 1 ms 1236 KB Output is correct
16 Correct 1 ms 1236 KB Output is correct
17 Correct 1 ms 1284 KB Output is correct
18 Correct 1 ms 1108 KB Output is correct
19 Correct 1 ms 1236 KB Output is correct
20 Correct 1 ms 1108 KB Output is correct
21 Correct 1 ms 1108 KB Output is correct
22 Correct 1 ms 1108 KB Output is correct
23 Correct 1 ms 1108 KB Output is correct
24 Correct 1 ms 1108 KB Output is correct
25 Correct 1 ms 1108 KB Output is correct
26 Correct 1 ms 1108 KB Output is correct
27 Correct 1 ms 1108 KB Output is correct
28 Correct 1 ms 1108 KB Output is correct
29 Correct 1 ms 1108 KB Output is correct
30 Correct 2 ms 1236 KB Output is correct
31 Correct 2 ms 1236 KB Output is correct
32 Correct 1 ms 1236 KB Output is correct

Subtask #3
0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 1 ms 1108 KB Output is correct
3 Correct 1 ms 1108 KB Output is correct
4 Correct 1 ms 1108 KB Output is correct
5 Correct 1 ms 1108 KB Output is correct
6 Correct 1 ms 1108 KB Output is correct
7 Correct 1 ms 1236 KB Output is correct
8 Correct 2 ms 1236 KB Output is correct
9 Correct 1 ms 1236 KB Output is correct
10 Correct 1 ms 1236 KB Output is correct
11 Correct 1 ms 1236 KB Output is correct
12 Correct 1 ms 1236 KB Output is correct
13 Correct 1 ms 1108 KB Output is correct
14 Correct 1 ms 1236 KB Output is correct
15 Correct 1 ms 1108 KB Output is correct
16 Correct 1 ms 1108 KB Output is correct
17 Correct 1 ms 1108 KB Output is correct
18 Correct 1 ms 1108 KB Output is correct
19 Correct 1 ms 1108 KB Output is correct
20 Correct 1 ms 1108 KB Output is correct
21 Correct 1 ms 1108 KB Output is correct
22 Correct 2 ms 1236 KB Output is correct
23 Correct 2 ms 1236 KB Output is correct
24 Correct 2 ms 1364 KB Output is correct
25 Correct 34 ms 4996 KB Output is correct
26 Correct 57 ms 7216 KB Output is correct
27 Correct 57 ms 7760 KB Output is correct
28 Correct 59 ms 7852 KB Output is correct
29 Correct 52 ms 8268 KB Output is correct
30 Correct 48 ms 8236 KB Output is correct
31 Correct 41 ms 7244 KB Output is correct
32 Correct 71 ms 7492 KB Output is correct
33 Correct 74 ms 7248 KB Output is correct
34 Correct 156 ms 14412 KB Output is correct
35 Correct 181 ms 18368 KB Output is correct
36 Correct 169 ms 18432 KB Output is correct
37 Correct 135 ms 18872 KB Output is correct
38 Correct 135 ms 18704 KB Output is correct
39 Correct 700 ms 49168 KB Output is correct
40 Execution timed out 2071 ms 143696 KB Time limit exceeded
41 Halted 0 ms 0 KB -

Subtask #4
19.0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 2 ms 1108 KB Output is correct
3 Correct 1 ms 1108 KB Output is correct
4 Correct 2 ms 1108 KB Output is correct
5 Correct 1 ms 1236 KB Output is correct
6 Correct 1 ms 1108 KB Output is correct
7 Correct 1 ms 1108 KB Output is correct
8 Correct 1 ms 1108 KB Output is correct
9 Correct 6 ms 1236 KB Output is correct
10 Correct 2 ms 1236 KB Output is correct
11 Correct 1 ms 1236 KB Output is correct
12 Correct 2 ms 1236 KB Output is correct
13 Correct 1 ms 1236 KB Output is correct
14 Correct 1 ms 1236 KB Output is correct
15 Correct 1 ms 1236 KB Output is correct
16 Correct 1 ms 1236 KB Output is correct
17 Correct 1 ms 1284 KB Output is correct
18 Correct 1 ms 1108 KB Output is correct
19 Correct 1 ms 1236 KB Output is correct
20 Correct 1 ms 1108 KB Output is correct
21 Correct 1 ms 1108 KB Output is correct
22 Correct 1 ms 1108 KB Output is correct
23 Correct 1 ms 1108 KB Output is correct
24 Correct 1 ms 1108 KB Output is correct
25 Correct 1 ms 1108 KB Output is correct
26 Correct 1 ms 1108 KB Output is correct
27 Correct 1 ms 1108 KB Output is correct
28 Correct 1 ms 1108 KB Output is correct
29 Correct 1 ms 1108 KB Output is correct
30 Correct 2 ms 1236 KB Output is correct
31 Correct 2 ms 1236 KB Output is correct
32 Correct 1 ms 1236 KB Output is correct
33 Correct 70 ms 7216 KB Output is correct
34 Correct 3 ms 1364 KB Output is correct
35 Correct 3 ms 1748 KB Output is correct
36 Correct 33 ms 4948 KB Output is correct
37 Correct 26 ms 8532 KB Output is correct
38 Correct 58 ms 7112 KB Output is correct
39 Correct 58 ms 7868 KB Output is correct
40 Correct 72 ms 7252 KB Output is correct
41 Correct 60 ms 7228 KB Output is correct
42 Correct 60 ms 7844 KB Output is correct
43 Correct 48 ms 8212 KB Output is correct
44 Correct 48 ms 8256 KB Output is correct
45 Correct 31 ms 9812 KB Output is correct
46 Correct 34 ms 9904 KB Output is correct
47 Correct 39 ms 9648 KB Output is correct
48 Correct 43 ms 7604 KB Output is correct
49 Correct 43 ms 7392 KB Output is correct
50 Correct 41 ms 7284 KB Output is correct
51 Correct 53 ms 7320 KB Output is correct
52 Correct 76 ms 7524 KB Output is correct
53 Correct 75 ms 7340 KB Output is correct
54 Correct 55 ms 7124 KB Output is correct

Subtask #5
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 2 ms 1108 KB Output is correct
3 Correct 1 ms 1108 KB Output is correct
4 Correct 2 ms 1108 KB Output is correct
5 Correct 1 ms 1236 KB Output is correct
6 Correct 1 ms 1108 KB Output is correct
7 Correct 1 ms 1108 KB Output is correct
8 Correct 1 ms 1108 KB Output is correct
9 Correct 6 ms 1236 KB Output is correct
10 Correct 2 ms 1236 KB Output is correct
11 Correct 1 ms 1236 KB Output is correct
12 Correct 2 ms 1236 KB Output is correct
13 Correct 1 ms 1236 KB Output is correct
14 Correct 1 ms 1236 KB Output is correct
15 Correct 1 ms 1236 KB Output is correct
16 Correct 1 ms 1236 KB Output is correct
17 Correct 1 ms 1284 KB Output is correct
18 Correct 1 ms 1108 KB Output is correct
19 Correct 1 ms 1236 KB Output is correct
20 Correct 1 ms 1108 KB Output is correct
21 Correct 1 ms 1108 KB Output is correct
22 Correct 1 ms 1108 KB Output is correct
23 Correct 1 ms 1108 KB Output is correct
24 Correct 1 ms 1108 KB Output is correct
25 Correct 1 ms 1108 KB Output is correct
26 Correct 1 ms 1108 KB Output is correct
27 Correct 1 ms 1108 KB Output is correct
28 Correct 1 ms 1108 KB Output is correct
29 Correct 1 ms 1108 KB Output is correct
30 Correct 2 ms 1236 KB Output is correct
31 Correct 2 ms 1236 KB Output is correct
32 Correct 1 ms 1236 KB Output is correct
33 Correct 70 ms 7216 KB Output is correct
34 Correct 3 ms 1364 KB Output is correct
35 Correct 3 ms 1748 KB Output is correct
36 Correct 33 ms 4948 KB Output is correct
37 Correct 26 ms 8532 KB Output is correct
38 Correct 58 ms 7112 KB Output is correct
39 Correct 58 ms 7868 KB Output is correct
40 Correct 72 ms 7252 KB Output is correct
41 Correct 60 ms 7228 KB Output is correct
42 Correct 60 ms 7844 KB Output is correct
43 Correct 48 ms 8212 KB Output is correct
44 Correct 48 ms 8256 KB Output is correct
45 Correct 31 ms 9812 KB Output is correct
46 Correct 34 ms 9904 KB Output is correct
47 Correct 39 ms 9648 KB Output is correct
48 Correct 43 ms 7604 KB Output is correct
49 Correct 43 ms 7392 KB Output is correct
50 Correct 41 ms 7284 KB Output is correct
51 Correct 53 ms 7320 KB Output is correct
52 Correct 76 ms 7524 KB Output is correct
53 Correct 75 ms 7340 KB Output is correct
54 Correct 55 ms 7124 KB Output is correct
55 Correct 209 ms 16284 KB Output is correct
56 Correct 45 ms 9852 KB Output is correct
57 Correct 155 ms 14412 KB Output is correct
58 Correct 130 ms 16204 KB Output is correct
59 Correct 184 ms 18392 KB Output is correct
60 Correct 206 ms 16340 KB Output is correct
61 Correct 197 ms 16268 KB Output is correct
62 Correct 165 ms 18412 KB Output is correct
63 Correct 135 ms 18728 KB Output is correct
64 Correct 138 ms 18780 KB Output is correct
65 Correct 80 ms 27608 KB Output is correct
66 Correct 100 ms 27696 KB Output is correct
67 Correct 105 ms 22408 KB Output is correct
68 Correct 114 ms 17076 KB Output is correct
69 Correct 113 ms 16628 KB Output is correct
70 Correct 116 ms 16504 KB Output is correct
71 Correct 125 ms 16712 KB Output is correct
72 Correct 216 ms 16764 KB Output is correct
73 Correct 219 ms 16516 KB Output is correct
74 Correct 165 ms 16280 KB Output is correct

Subtask #6
0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 1 ms 1108 KB Output is correct
3 Correct 1 ms 1236 KB Output is correct
4 Correct 1 ms 1236 KB Output is correct
5 Correct 2 ms 1236 KB Output is correct
6 Correct 2 ms 1236 KB Output is correct
7 Correct 1 ms 1236 KB Output is correct
8 Correct 2 ms 1236 KB Output is correct
9 Correct 1 ms 1108 KB Output is correct
10 Correct 1 ms 1108 KB Output is correct
11 Correct 1 ms 1108 KB Output is correct
12 Correct 1 ms 1108 KB Output is correct
13 Correct 1 ms 1108 KB Output is correct
14 Correct 1 ms 1108 KB Output is correct
15 Correct 1 ms 1108 KB Output is correct
16 Correct 2 ms 1236 KB Output is correct
17 Correct 1 ms 1236 KB Output is correct
18 Correct 2 ms 1236 KB Output is correct
19 Correct 72 ms 7108 KB Output is correct
20 Correct 26 ms 8556 KB Output is correct
21 Correct 59 ms 7848 KB Output is correct
22 Correct 71 ms 7264 KB Output is correct
23 Correct 63 ms 7224 KB Output is correct
24 Correct 29 ms 9812 KB Output is correct
25 Correct 35 ms 9884 KB Output is correct
26 Correct 74 ms 7520 KB Output is correct
27 Correct 77 ms 7252 KB Output is correct
28 Correct 57 ms 7136 KB Output is correct
29 Correct 217 ms 16200 KB Output is correct
30 Correct 44 ms 9788 KB Output is correct
31 Correct 183 ms 18368 KB Output is correct
32 Correct 207 ms 16384 KB Output is correct
33 Correct 202 ms 16288 KB Output is correct
34 Correct 79 ms 27624 KB Output is correct
35 Correct 89 ms 27672 KB Output is correct
36 Correct 218 ms 16768 KB Output is correct
37 Correct 228 ms 16520 KB Output is correct
38 Correct 167 ms 16212 KB Output is correct
39 Execution timed out 2085 ms 151464 KB Time limit exceeded
40 Halted 0 ms 0 KB -

Subtask #7
0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 1 ms 1108 KB Output is correct
3 Correct 1 ms 1236 KB Output is correct
4 Correct 1 ms 1236 KB Output is correct
5 Correct 2 ms 1236 KB Output is correct
6 Correct 2 ms 1236 KB Output is correct
7 Correct 1 ms 1236 KB Output is correct
8 Correct 2 ms 1236 KB Output is correct
9 Correct 1 ms 1108 KB Output is correct
10 Correct 1 ms 1108 KB Output is correct
11 Correct 1 ms 1108 KB Output is correct
12 Correct 1 ms 1108 KB Output is correct
13 Correct 1 ms 1108 KB Output is correct
14 Correct 1 ms 1108 KB Output is correct
15 Correct 1 ms 1108 KB Output is correct
16 Correct 2 ms 1236 KB Output is correct
17 Correct 1 ms 1236 KB Output is correct
18 Correct 2 ms 1236 KB Output is correct
19 Correct 72 ms 7108 KB Output is correct
20 Correct 26 ms 8556 KB Output is correct
21 Correct 59 ms 7848 KB Output is correct
22 Correct 71 ms 7264 KB Output is correct
23 Correct 63 ms 7224 KB Output is correct
24 Correct 29 ms 9812 KB Output is correct
25 Correct 35 ms 9884 KB Output is correct
26 Correct 74 ms 7520 KB Output is correct
27 Correct 77 ms 7252 KB Output is correct
28 Correct 57 ms 7136 KB Output is correct
29 Correct 217 ms 16200 KB Output is correct
30 Correct 44 ms 9788 KB Output is correct
31 Correct 183 ms 18368 KB Output is correct
32 Correct 207 ms 16384 KB Output is correct
33 Correct 202 ms 16288 KB Output is correct
34 Correct 79 ms 27624 KB Output is correct
35 Correct 89 ms 27672 KB Output is correct
36 Correct 218 ms 16768 KB Output is correct
37 Correct 228 ms 16520 KB Output is correct
38 Correct 167 ms 16212 KB Output is correct
39 Execution timed out 2085 ms 151464 KB Time limit exceeded
40 Halted 0 ms 0 KB -

Subtask #8
0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 1108 KB Output is correct
2 Correct 1 ms 1108 KB Output is correct
3 Correct 1 ms 1236 KB Output is correct
4 Correct 1 ms 1236 KB Output is correct
5 Correct 2 ms 1236 KB Output is correct
6 Correct 2 ms 1236 KB Output is correct
7 Correct 1 ms 1236 KB Output is correct
8 Correct 2 ms 1236 KB Output is correct
9 Correct 1 ms 1108 KB Output is correct
10 Correct 1 ms 1108 KB Output is correct
11 Correct 1 ms 1108 KB Output is correct
12 Correct 1 ms 1108 KB Output is correct
13 Correct 1 ms 1108 KB Output is correct
14 Correct 1 ms 1108 KB Output is correct
15 Correct 1 ms 1108 KB Output is correct
16 Correct 2 ms 1236 KB Output is correct
17 Correct 1 ms 1236 KB Output is correct
18 Correct 2 ms 1236 KB Output is correct
19 Correct 72 ms 7108 KB Output is correct
20 Correct 26 ms 8556 KB Output is correct
21 Correct 59 ms 7848 KB Output is correct
22 Correct 71 ms 7264 KB Output is correct
23 Correct 63 ms 7224 KB Output is correct
24 Correct 29 ms 9812 KB Output is correct
25 Correct 35 ms 9884 KB Output is correct
26 Correct 74 ms 7520 KB Output is correct
27 Correct 77 ms 7252 KB Output is correct
28 Correct 57 ms 7136 KB Output is correct
29 Correct 217 ms 16200 KB Output is correct
30 Correct 44 ms 9788 KB Output is correct
31 Correct 183 ms 18368 KB Output is correct
32 Correct 207 ms 16384 KB Output is correct
33 Correct 202 ms 16288 KB Output is correct
34 Correct 79 ms 27624 KB Output is correct
35 Correct 89 ms 27672 KB Output is correct
36 Correct 218 ms 16768 KB Output is correct
37 Correct 228 ms 16520 KB Output is correct
38 Correct 167 ms 16212 KB Output is correct
39 Execution timed out 2085 ms 151464 KB Time limit exceeded
40 Halted 0 ms 0 KB -