Submission #1019237

#	Time	Username	Problem	Language	Result	Execution time	Memory
1019237		cadmiumsky	Radio Towers (IOI22_towers)	C++17	100 / 100	1986 ms	472172 KiB

towers

#include "towers.h"
 
#include <vector>
#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
using namespace std;
 
using ll = long long;
using ld = long double;
 
#define int ll
#define sz(x) ((int)(x).size())
 
using pii = pair<int,int>;
using tii = tuple<int,int,int>;
 
const int nmax = 2e5 + 5;
int v[nmax];
 
namespace DSU {
   int dsu[nmax], nxt[nmax];
   int mxR[nmax];
 
   void init(int l, int r) {
      for(int i = l; i <= r; i++) dsu[i] = i, nxt[i] = i + 1;
      return;
   }
   int f(int x) { return x == dsu[x]? x : dsu[x] = f(dsu[x]); }
   void unite(int x, int y) {
      x = f(x);
      y = f(y);
      if(x == y) return;
      if(x > y) swap(x, y);
      dsu[y] = x;
      mxR[x] = max(mxR[x], mxR[y]);
      nxt[x] = nxt[y];
      return;
   }
   int coef(int i, const vector<int>& p) {
      i = f(i);
      return mxR[i] - max(v[p[i]], v[p[nxt[i]]]);
   }
}
 
int timeout[nmax];
int dir[nmax];
 
void initglobals(signed L, signed R) {
   
   ++L;
   ++R;
   
   vector<int> p;
   for(int i = L; i <= R; i++) {
      if((i == L  || v[i] < v[i - 1]) && (i == R || v[i] < v[i + 1])) p.emplace_back(i), timeout[i] = 1e9 + 5;
      else timeout[i] = 0;
   }
   
   DSU::init(0, sz(p));
   
   set<pii> heap;
   
   set<int> indemnizatii;
   for(int i = 0; i < sz(p) - 1; i++) {
      indemnizatii.emplace(i);
      indemnizatii.emplace(i + 1);
      int mx = v[p[i] + 1];
      for(int j = p[i] + 2; j < p[i + 1]; j++)
         mx = max(mx, v[j]);
      DSU::mxR[i] = mx;
      heap.emplace(mx - max(v[p[i]], v[p[i + 1]]), i);
   }
   
   auto get = [&](int p_) { return pii{DSU::coef(p_, p), p_}; };
      
   while(!heap.empty()) {
      auto [C, i] = *heap.begin();
      heap.erase(heap.begin());
      
      i = DSU::f(i);
      int urm = DSU::nxt[i];
      if(i != *indemnizatii.begin()) {
         int ant = DSU::f(i - 1);
         heap.erase(heap.find(get(ant)));
      }
      if(urm != *indemnizatii.rbegin()) 
         heap.erase(heap.find(get(urm)));
      
      if(v[p[i]] < v[p[urm]]) {
         timeout[p[urm]] = C;
         dir[p[urm]] = p[i];
         DSU::unite(i, urm);
         indemnizatii.erase(urm);
         if(i != *indemnizatii.begin()) {
            int ant = DSU::f(i - 1);
            heap.insert(get(ant));
         }
         if(i != *indemnizatii.rbegin())
            heap.insert(get(i));
         
      }
      else {
         timeout[p[i]] = C;
         dir[p[i]] = p[urm];
         if(i != *indemnizatii.begin()) {
            int ant = DSU::f(i - 1);
            DSU::unite(ant, i);
            heap.insert(get(ant));
         }
         if(urm != *indemnizatii.rbegin())
            heap.insert(get(urm));
         indemnizatii.erase(i);
      }  
   }
}
 
 

template<typename T>
struct AINT {
   struct Node {
      Node *l, *r;
      T inner; 
   };
   using ns = Node*;
   Node mem[nmax * 32];
   int cnt = 0;
   int n;
   
   ns nil, root;
   
   ns newnode(ns L, ns R, T val) { mem[cnt++] = Node{L, R, val}; return mem + cnt - 1; }
   ns newnode() { return newnode(nil, nil, T()); }
   
   void init(int n_) {
      n = n_;
      nil = newnode(nil, nil, T()); nil -> l = nil -> r = nil; nil -> inner = T();
      root = nil;
      walk([&](T& a, int cl, int cr) { 
         if(cl != cr) return 1;
         a = T();
         return 0;
      });
   }
   
   template<class CB> ns walk(CB&& cb) { return root = walk<0>(cb, root, 1, n); }
   template<class CB> ns walk(CB&& cb, int l, int r) { return root = walk<0>(cb, root, l, r); }
   template<class CB> void const_walk(CB&& cb, ns start) { const_walk(cb, start, 1, n); }
   template<class CB> void const_walk(CB&& cb, ns start, int l, int r) { walk<1>(cb, l, r, start, 1, n); }
   template<int cst = 0, class CB> ns walk(CB&& cb, ns start, int l, int r) { return walk<cst>(cb, l, r, start, 1, n); }
   
   template<int cst, class CB> ns walk(CB&& cb, int l, int r, ns node, int cl, int cr) {
      if(cr < l || r < cl) return node;
      auto a = node -> inner;
      if(l <= cl && cr <= r && !cb(a, cl, cr)) {
         if(cst) return node;
         return newnode(node -> l, node -> r, a);
      }
      int mid = (cl + cr) >> 1;
      auto L = walk<cst>(cb, l, r, node -> l, cl, mid);
      auto R = walk<cst>(cb, l, r, node -> r, mid + 1, cr);
      if(!cst) node = newnode();
      node -> l = L, node -> r = R, node -> inner.pull(L -> inner, R -> inner);
      return node;
   }  
};
 
struct Sum {
   int val;
   Sum(int a = 0): val(a) {;}
   void pull(const Sum& L, const Sum& R) { val = L.val + R.val; }
};
 
struct mnidx {
   int val;
   mnidx(int a = 0): val(a) {;}
   void pull(const mnidx& L, const mnidx& R) { val = v[L.val] < v[R.val]? L.val : R.val; }
};
 
struct mxval {
   int val;
   mxval(int a = 0): val(a) {;}
   void pull(const mxval& L, const mxval& R) { val = max(L.val, R.val); }
};
 
map<int, AINT<Sum>::ns> sumroot;
map<int, AINT<mnidx>::ns> raiseroot, fallroot;
 
AINT<Sum> sum_aint;
AINT<mnidx> dir_aint;
AINT<mxval> max_aint;
 
void init(signed N, std::vector<signed> H) {
   //cerr << N << ' ' << sz(H) << '\n';
   v[0] = 1e9 + 2;
   for(int i = 0; i < N; i++) v[i + 1] = H[i]; 
   initglobals(0, N - 1);
   max_aint.init(N);
   max_aint.walk([&](auto &a, int cl, int cr) { if(cl != cr) return 1; a.val = v[cl]; return 0; });
   
 
   vector<int> idx(N); iota(all(idx), 1);
   sum_aint.init(N);
   //cerr << sum_aint.root -> inner.val << '\n';
   sort(all(idx), [&](int a, int b) { return timeout[a] > timeout[b]; });
   for(auto x : idx)
      sumroot[timeout[x]] = sum_aint.walk([&](auto& a, int cl, int cr) {  a.val = 1; return 0;}, x, x);
      //cerr << timeout[x] << '\t' << sum_aint.root -> inner.val << '\n';
      
   dir_aint.init(N);
   sort(all(idx), [&](int a, int b) { return dir[a] < dir[b]; });
   raiseroot[0] = dir_aint.root;
   for(auto x : idx) 
      raiseroot[dir[x]] = dir_aint.walk([&](auto& a, int cl, int cr) { a.val = cl * (timeout[cl] != 0); return 0; }, x, x); 
   for(int i = 1; i <= N; i++) if(raiseroot.count(i) == 0) raiseroot[i] = raiseroot[i - 1];
   
   dir_aint.init(N);
   sort(all(idx), [&](int a, int b) { return dir[a] > dir[b]; });
   fallroot[N + 1] = dir_aint.root;
   for(auto x : idx) 
      fallroot[dir[x]] = dir_aint.walk([&](auto& a, int cl, int cr) { a.val = cl * (timeout[cl] != 0); return 0; }, x, x); 
   for(int i = N; i > 0; i--) if(fallroot.count(i) == 0) fallroot[i] = fallroot[i + 1];
   
   
   return;
}
 
int query_max(int l, int r) { 
   int mx = 0;
   max_aint.const_walk([&](auto& a, int cl, int cr) { mx = max(mx, a.val); return 0;}, max_aint.root, l, r);
   return mx;
}
 
signed max_towers(signed L, signed R, signed D) {
   ++L, ++R;
   if(sumroot.lower_bound(D) == sumroot.end()) {
      JOEVER:
      int mnL = L;
      dir_aint.const_walk([&](mnidx& a, int cl, int cr) { if(v[mnL] > v[a.val]) mnL = a.val; return 0;}, raiseroot[L - 1], L , R);
      int mnR = R;
      dir_aint.const_walk([&](mnidx& a, int cl, int cr) { if(v[mnR] > v[a.val]) mnR = a.val; return 0;}, fallroot[R + 1], L , R);
      if(mnL > mnR) return 1;
      
      return query_max(mnL, mnR) - max(v[mnL], v[mnR]) >= D? 2 : 1;
   }
   int alltogether = 0;
   auto forsum = sumroot.lower_bound(D) -> second;
   
   sum_aint.const_walk([&](auto a, int cl, int cr) { alltogether += a.val; return 0; }, forsum, L, R);
   if(alltogether == 0) {
      goto JOEVER;
   }
   
   
   int l = L, r;
   sum_aint.const_walk([&](auto &a, int cl, int cr) { 
      if(l < cl) return 0; 
      if(a.val == 0) { l = cr + 1; return 0; } 
      if(cl == cr) { l = cl; return 0; } 
      return 1; }, forsum, L, R);
   
   int rez = alltogether;
   
   if(L < l) {
      int mn = L;
      dir_aint.const_walk([&](mnidx& a, int cl, int cr) { if(v[mn] > v[a.val]) mn = a.val; return 0;}, raiseroot[L - 1], L + 1, l - 1);
      int mx = query_max(mn + 1, l);
      
      if(mx - max(v[l], v[mn]) >= D) rez++;
   }
   int limit = alltogether - 1;
   
   r = L;
   sum_aint.const_walk([&](auto &a, int cl, int cr) { 
      if(r < cl) return 0; 
      if(a.val <= limit) { limit -= a.val; r = cr + 1; return 0; } 
      if(cl == cr) { r = cl; return 0; } 
      return 1; }, forsum, L, R);
   
   
   if(r < R) {
      int mn = R;
      dir_aint.const_walk([&](mnidx& a, int cl, int cr) { if(v[mn] > v[a.val]) mn = a.val; return 0;}, fallroot[R + 1], r + 1, R - 1);
      int mx = query_max(r + 1, mn - 1);
      if(mx - max(v[r], v[mn]) >= D) rez++;
   }
   
   //cerr << L << ' ' << l << ' ' << r << ' ' << R << '\n';
   
   return rez;
}
#undef int

• Subtask 1: 4 / 4
• Subtask 2: 11 / 11
• Subtask 3: 12 / 12
• Subtask 4: 14 / 14
• Subtask 5: 17 / 17
• Subtask 6: 19 / 19
• Subtask 7: 23 / 23