Submission #1267377

#	Time	Username	Problem	Language	Result	Execution time	Memory
1267377		LucaLucaM	Two Antennas (JOI19_antennas)	C++20	100 / 100	416 ms	35732 KiB

antennas

#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>

using ll = long long;
#define debug(x) #x << " = " << x << '\n'

const int INF = 1e9;

struct segtree {
  struct Node {
    int maxAll; // max delta
    int maxActive; // h maxim
    int lazy; // delta max= h - lazy
    Node() : maxAll(-1), maxActive(-INF), lazy(+INF) {}
    Node(int x, int y, int z) : maxAll(x), maxActive(y), lazy(z) {}
    Node operator + (const Node &other) const {
      Node ret;
      ret.maxAll = std::max(maxAll, other.maxAll);
      ret.maxActive = std::max(maxActive, other.maxActive);
      ret.lazy = +INF;
      return ret;
    };
  };

  int n;
  std::vector<Node> aint;

  void init(int _n) {
    n = _n;
    aint.resize(4 * n + 10);
    for (int i = 0; i < 4 * n + 10; i++) {
      aint[i] = Node(-1, -INF, +INF);
    }
  }

  void push(int node, int tl, int tr) {
    aint[node].maxAll = std::max(aint[node].maxAll, aint[node].maxActive - aint[node].lazy);
    if (tl != tr) {
      aint[2 * node].lazy = std::min(aint[2 * node].lazy, aint[node].lazy);
      aint[2 * node + 1].lazy = std::min(aint[2 * node + 1].lazy, aint[node].lazy);
    }
    aint[node].lazy = +INF;
  }

  void updateH(int node, int tl, int tr, int p, int v) { // se schimba h
    push(node, tl, tr);
    if (tl == tr) {
      aint[node].maxActive = v;
    } else {
      int mid = (tl + tr) / 2;
      if (p <= mid) {
        updateH(2 * node, tl, mid, p, v);
      } else {
        updateH(2 * node + 1, mid + 1, tr, p, v);
      }
      push(2 * node, tl, mid);
      push(2 * node + 1, mid + 1, tr);
      aint[node] = aint[2 * node] + aint[2 * node + 1];
    }
  }
  void update(int node, int tl, int tr, int l, int r, int v) { // a[l] max= h[l] - v 
    push(node, tl, tr);
    if (l <= tl && tr <= r) {
      aint[node].lazy = v;
    } else {
      int mid = (tl + tr) / 2;
      if (l <= mid) {
        update(2 * node, tl, mid, l, r, v);
      } 
      if (mid < r) {
        update(2 * node + 1, mid + 1, tr, l, r, v);
      }
      push(2 * node, tl, mid);
      push(2 * node + 1, mid + 1, tr);
      aint[node] = aint[2 * node] + aint[2 * node + 1];
    }
  }
  int query(int node, int tl, int tr, int l, int r) {
    push(node, tl, tr);
    if (l <= tl && tr <= r) {
      return aint[node].maxAll;
    }
    int mid = (tl + tr) / 2;
    if (l <= mid && mid < r) {
      return std::max(query(2 * node, tl, mid, l, r), query(2 * node + 1, mid + 1, tr, l, r));
    } else if (l <= mid) {
      return query(2 * node, tl, mid, l, r);
    } else {
// aici a fost pierduta 1h VVVVV  (neaparat trebuie pus aceset +1)
      return query(2 * node + 1, mid + 1, tr, l, r);
    }
  }

  void updateH(int p, int newH) {
    updateH(1, 1, n, p + 1, newH);
  }
  void update(int l, int r, int v) {
    if (l > r) {
      return;
    }
    update(1, 1, n, l + 1, r + 1, v);
  }
  int query(int l, int r) {
    return query(1, 1, n, l + 1, r + 1);
  }
};

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);
  std::cout.tie(0);
  
  int n;
  std::cin >> n;

  std::vector<int> h(n), lt(n), rt(n);

  for (int i = 0; i < n; i++) {
    std::cin >> h[i] >> lt[i] >> rt[i];
  }

  int q;
  std::cin >> q;

  std::vector<std::pair<int, int>> Q(q);
  std::vector<int> answer(q, -1);
  for (auto &[l, r] : Q) {
    std::cin >> l >> r;
    l--, r--;
  }

  auto solve = [&]() {
    std::vector<int> l(n), r(n), l2(n), r2(n);
    std::vector<std::vector<int>> events(n);
    std::vector<std::vector<int>> queries(n);

    for (int i = 0; i < n; i++) {
      l[i] = lt[i] + i;
      r[i] = rt[i] + i;
      l2[i] = i - rt[i];
      r2[i] = i - lt[i];
      if (r[i] + 1 < n) {
        events[r[i] + 1].push_back(-(i + 1));
      }
      if (l[i] < n) {
        events[std::max(0, l[i])].push_back(+(i + 1));
      }
      l2[i] = std::max(l2[i], 0);
      r2[i] = std::min(r2[i], n - 1);
    }

    for (int i = 0; i < q; i++) {
      queries[Q[i].second].push_back(i);
    }
    
    segtree DS;
    DS.init(n);

    for (int i = 0; i < n; i++) {
      std::sort(events[i].begin(), events[i].end());
      for (int j : events[i]) {
        int p = std::abs(j) - 1;
        if (j > 0) { // add
          DS.updateH(p, h[p]);
        } else { // remove
          DS.updateH(p, -INF);
        }
      }

      DS.update(l2[i], r2[i], h[i]);

      for (int id : queries[i]) {
        auto [l, r] = Q[id];
        answer[id] = std::max(answer[id], DS.query(l, r));
      }
    }
  };

  solve();
  
  std::reverse(h.begin(), h.end());
  std::reverse(lt.begin(), lt.end());
  std::reverse(rt.begin(), rt.end());

  for (auto &[l, r] : Q) {
    l = n - 1 - l;
    r = n - 1 - r;
    std::swap(l, r);
  }

  solve();

  for (int x : answer) {
    std::cout << x << '\n';
  }
  
  return 0;
}

• Subtask 1: 2 / 2
• Subtask 2: 11 / 11
• Subtask 3: 22 / 22
• Subtask 4: 65 / 65