Submission #548441

#	Time	Username	Problem	Language	Result	Execution time	Memory
548441		lorenzoferrari	Game (IOI13_game)	C++17	0 / 100	0 ms	224 KiB

game

#include "game.h"
#include <bits/stdc++.h>
// #pragma GCC optimize ("O3")
using namespace std;
using LL = long long;

constexpr int LIM = 1e9 + 1;

int R;
int C;

inline LL gcd(LL a, LL b) {
  LL x;
  while (a != b && b != 0) {
    x = a;
    a = b;
    b = x % b;
  }
  return a;
}
long long gcd2(long long X, long long Y) {
    long long tmp;
    while (X != Y && Y != 0) {
        tmp = X;
        X = Y;
        Y = tmp % Y;
    }
    return X;
}

struct st {
  // static vector<st> pool_st;
  static st * new_st(int a = 0, int b = C+5) {
    auto ret = new st;
    ret->a = a;
    ret->b = b;
    return ret;
    // pool_st.resize(pool_st.size() + 1);
    // pool_st.back().a = a;
    // pool_st.back().b = b;
    // return &pool_st.back();
  }
  int a = 0, b = C+5;
  st * l = nullptr;
  st * r = nullptr;
  LL g = 0;
  st() {}
  ~st() {
    if (l) delete l;
    if (r) delete r;
  }
  friend void update(st * const n, const int p, const LL k) {
    if (p < n->a || n->b <= p) return;
    n->g = gcd(n->g, k);
    // if (n) cerr << "st_update: " << "[" << n->a << " " << n->b << "), " << p << " " << k << " - g: " << n->g << endl;
    if (n->b - n->a <= 1) return;
    int m = (n->a+n->b) / 2;
    if (p < m) {
      if (!n->l) n->l = new_st(n->a, m);
      update(n->l, p, k);
      return;
    } else {
      if (!n->r) n->r = new_st(m, n->b);
      update(n->r, p, k);
      return;
    }
  }
  friend LL query(const st * const n, const int l, const int r) {
    if (!n || r <= n->a || n->b <= l) return 0LL;
    if (l <= n->a && n->b <= r) return n->g;
    return gcd(query(n->l, l, r), query(n->r, l, r));
  }
};

struct sst {
  static vector<sst> pool_sst;
  static sst * new_sst(int a = 0, int b = R+5) {
    auto ret = new sst;
    ret->a = a;
    ret->b = b;
    return ret;
    // pool_sst.resize(pool_sst.size() + 1);
    // pool_sst.back().a = a;
    // pool_sst.back().b = b;
    // return &pool_sst.back();
  }
  int a = 0, b = R+5;
  sst * l = nullptr;
  sst * r = nullptr;
  st * son = nullptr;
  sst() {}
  ~sst() {
    if (l) delete l;
    if (r) delete r;
    if (son) delete son;
  }
  friend void sst_update(sst * const n, const int p, const int q, const LL k) {
    // if (n) cerr << "sst_update: " << "[" << n->a << " " << n->b << "), " << p << " " << q << " " << k << endl;
    // if (!n) cerr << "nope\n";
    if (p < n->a || n->b <= p) return;
    if (!n->son) n->son = st::new_st();
    update(n->son, q, k);
    if (n->b - n->a <= 1) return;
    int m = (n->a+n->b) / 2;
    if (p < m) {
      if (!n->l) n->l = new_sst(n->a, m);
      sst_update(n->l, p, q, k);
      return;
    } else {
      if (!n->r) n->r = new_sst(m, n->b);
      sst_update(n->r, p, q, k);
      return;
    }
  }
  friend LL sst_query(const sst * const n, const int p, const int q, const int u, const int v) {
    // if (n)  cerr << "sst_query: " << "[" << n->a << " " << n->b << "), " << p << " " << q << " " << u << " " << v << endl;
    // if (!n) cerr << "nope\n";

    if (!n || u <= n->a || n->b <= p) return 0LL;
    if (p <= n->a && n->b <= u) return query(n->son, q, v);
    return gcd(sst_query(n->l, p, q, u, v), sst_query(n->r, p, q, u, v));
  }
};

// st::pool_st = vector<st>;
// sst::pool_sst = vector<sst>;
sst * root;

void cleanup() {
  delete root;
}

vector<array<LL, 3>> h;

void init(int r, int c) {
  R = r+5; C = c+5;
  // root = sst::new_sst(0, r+5);
  // root = sst::new_sst();
  assert(atexit(cleanup) == 0);
}

void update(int p, int q, LL k) {
  h.push_back({p, q, k});
  return;
  sst_update(root, p, q, k);
}

LL calculate(int p, int q, int u, int v) {
  LL ans = 0;
  for (auto& [x, y, k] : h) {
    if (p <= x && x <= u && q <= y && y <= v) {
      ans = (ans == 0 ? k : gcd2(ans, k));
    }
  }
  return ans;
  return sst_query(root, p, q, u+1, v+1);
}

• Subtask 1: 0 / 10
• Subtask 2: 0 / 27
• Subtask 3: 0 / 26
• Subtask 4: 0 / 17
• Subtask 5: 0 / 20