oj.uz

Submission #761203

# Submission time Handle Problem Language Result Execution time Memory
761203 2023-06-19T11:00:39 Z coloboxx Wall (IOI14_wall) C++17
8 / 100
 442 ms 262144 KB 
#include "wall.h"
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx,avx2,sse2,sse3,ssse3,sse4,lzcnt,popcnt")

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

#define ll long long
#define point pair<int, int>
#define X first
#define Y second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define show(x) cerr << (#x) << " = " << x << '\n'
#define print(x) if (1) {cerr << (#x) << " = "; for (auto it : x) \
      cerr << it << ' '; cerr << '\n';}
#define fast_io ios_base::sync_with_stdio(0), cin.tie(0)

const int N = 1 << 21;
const int K = 1 << 19;
const int S = 1e7 + 64;
const int INF = 2e9 + 64;
const ll MAX = 2e18 + 64;
const int LOG = 21;
const int MOD = 1e9 + 7; //998244353;
const int P = 79;

using namespace std;

vector<point> t[4 * N];

template <class T, T (*F) (T, T)>
struct segtree{
      int n;
      T def{};
      vector<T> t;
 
      segtree(int n, T def, vector<T> v = {}) : n(n), def(def) {
            t.assign(2 * n, def);

            for (int i = 0; i < min(n, (int)v.size()); ++i)
                  t[i + n] = v[i];

            for (int i = n - 1; i > 0; --i)
                  t[i] = F(t[i << 1], t[i << 1 | 1]);
      }
 
      void update(int p, T val) {
            for (t[p += n] = val; p > 1; p >>= 1)
                  t[p >> 1] = F(t[p], t[p ^ 1]);
      }

      T query(int l, int r) {
            T res = def;
            for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
                  if (l & 1) res = F(res, t[l++]);
                  if (r & 1) res = F(res, t[--r]);
            }
            return res;
      }
};

int type[N];

void add_segment(int v, int tl, int tr, int l, int r, int op, int id) {
      if (max(l, tl) > min(r, tr))
            return;

      if (l <= tl && r >= tr) {
            t[v].pb({op, id}); return;
      }

      int tm = (tl + tr) >> 1;
      add_segment(v << 1, tl, tm, l, r, op, id);
      add_segment(v << 1 | 1, tm + 1, tr, l, r, op, id);
}

int Min(int x, int y) { 
      return min(x, y);
}

int Max(int x, int y) {
      return max(x, y);
}

segtree<int, &Min> tmin(K, INF);
segtree<int, &Max> tmax(K, -INF);

int a[N], ans[N];

int norm(int l, int r, int x) {
      if (x < l) return l;
      if (x > r) return r;
      return x;
}

int n, k;

void dfs(int v, int tl, int tr, int mx_id = -INF) {
      // show(v);
      for (auto [op, id] : t[v]) {
            mx_id = max(mx_id, id);
            if (type[id] == 2)
                  tmin.update(id, op);
            else
                  tmax.update(id, op);
      }

      if (tl == tr) {
            // show(tl);
            if (mx_id == -INF) {
                  ans[tl] = 0;
            }
            else {
                  //cerr << "AAA\n";

                  int lb = -1, rb = mx_id;
                  // show(mx_id);

                  while (lb + 1 < rb) {
                        int mid = (lb + rb) >> 1;

                        int l = tmax.query(mid, mx_id);
                        int r = tmin.query(mid, mx_id);

                        (l <= r ? rb : lb) = mid;
                  }

                  int pos = rb;
                  int l = tmax.query(pos, mx_id);
                  int r = tmin.query(pos, mx_id);

                  // show(l), show(r);

                  if (pos == 0)
                        ans[tl] = norm(l, r, a[tl]);
                  else {
                        int pl = tmax.query(pos - 1, pos - 1);
                        int pr = tmin.query(pos - 1, pos - 1);

                        assert(max(l, pl) > min(r, pr));
                        // show(pl), show(pr);

                        if (pr < l)
                              ans[tl] = l;
                        else
                              ans[tl] = r;
                  }
                  //cerr << "BBB\n";
            }

            // for (int j = 0; j < k; ++j)
            //       cerr << "{" << tmax.query(j, j) << ", " << tmin.query(j, j) << "}\n";
      }
      else {
            int tm = (tl + tr) >> 1;
            dfs(v << 1, tl, tm, mx_id);
            dfs(v << 1 | 1, tm + 1, tr, mx_id);
      }

      for (auto [op, id] : t[v]) {
            mx_id = max(mx_id, id);
            if (type[id] == 2)
                  tmin.update(id, INF);
            else
                  tmax.update(id, -INF);
      }
}

void buildWall(int _n, int _k, int op[], int left[], int right[], int height[], int finalHeight[]) {
      n = _n, k = _k;

      for (int i = 0; i < k; ++i) {
            type[i] = op[i];
            add_segment(1, 0, n - 1, left[i], right[i], height[i], i);
      }

      dfs(1, 0, n - 1);
      for (int i = 0; i < n; ++i)
            finalHeight[i] = ans[i];
}


// int main()
// {
//       int n;
//       int k;

//       // for (int i = 0; i < 10; ++i)
//       //     show(tmin.query(i, i));
//       //     show(tmin.def);

//       int i, j;  
//       int status = 0;

//       status = scanf("%d%d", &n, &k);
//       assert(status == 2);

//       int* op = (int*)calloc(sizeof(int), k);
//       int* left = (int*)calloc(sizeof(int), k);
//       int* right = (int*)calloc(sizeof(int), k);
//       int* height = (int*)calloc(sizeof(int), k);
//       int* finalHeight = (int*)calloc(sizeof(int), n);

//       for (i = 0; i < k; i++){
//       status = scanf("%d%d%d%d", &op[i], &left[i], &right[i], &height[i]);
//       assert(status == 4);
//       }

//       buildWall(n, k, op, left, right, height, finalHeight);

//       for (j = 0; j < n; j++)
//       printf("%d\n", finalHeight[j]);

//       return 0;
// }

Subtask #1
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 93 ms 205444 KB Output is correct
2 Correct 94 ms 205656 KB Output is correct
3 Correct 95 ms 205648 KB Output is correct
4 Correct 103 ms 206544 KB Output is correct
5 Correct 106 ms 206336 KB Output is correct
6 Correct 105 ms 206380 KB Output is correct

Subtask #2
0 / 24.0

# Verdict Execution time Memory Grader output
1 Correct 109 ms 205436 KB Output is correct
2 Correct 226 ms 225208 KB Output is correct
3 Correct 394 ms 240620 KB Output is correct
4 Runtime error 433 ms 262144 KB Execution killed with signal 9
5 Halted 0 ms 0 KB -

Subtask #3
0 / 29.0

# Verdict Execution time Memory Grader output
1 Correct 94 ms 205508 KB Output is correct
2 Correct 96 ms 205724 KB Output is correct
3 Correct 105 ms 205616 KB Output is correct
4 Correct 104 ms 206580 KB Output is correct
5 Correct 105 ms 206328 KB Output is correct
6 Correct 105 ms 206388 KB Output is correct
7 Correct 94 ms 205516 KB Output is correct
8 Correct 221 ms 225072 KB Output is correct
9 Correct 391 ms 240588 KB Output is correct
10 Runtime error 442 ms 262144 KB Execution killed with signal 9
11 Halted 0 ms 0 KB -

Subtask #4
0 / 39.0

# Verdict Execution time Memory Grader output
1 Correct 93 ms 205448 KB Output is correct
2 Correct 96 ms 205712 KB Output is correct
3 Correct 95 ms 205636 KB Output is correct
4 Correct 122 ms 206540 KB Output is correct
5 Correct 110 ms 206416 KB Output is correct
6 Correct 104 ms 206356 KB Output is correct
7 Correct 94 ms 205516 KB Output is correct
8 Correct 220 ms 225084 KB Output is correct
9 Correct 388 ms 240628 KB Output is correct
10 Runtime error 414 ms 262144 KB Execution killed with signal 9
11 Halted 0 ms 0 KB -