test/yukicoder/2332.RH.test.cpp

• View this file on GitHub
• Last update: 2024-10-01 17:03:34+09:00
• Problem: https://yukicoder.me/problems/no/2332

Depends on

• 関数型や関数オブジェクトに関するテンプレート (src/Internal/function_traits.hpp)
• modintを扱うテンプレート (src/Internal/modint_traits.hpp)
• 剰余の高速化 (src/Internal/Remainder.hpp)
• 逆元 ($\mathbb{Z}/m\mathbb{Z}$) (src/Math/mod_inv.hpp)
• ModInt (src/Math/ModInt.hpp)
• 体を並列に扱う ($K_1\times K_2\times\cdots\times K_n$) (src/Misc/Pointwise.hpp)
• 疑似乱数 (src/Misc/rng.hpp)
• Li-Chao-Tree (src/Optimization/LiChaoTree.hpp)
• 最大最小を指定するための列挙型 (src/Optimization/MinMaxEnum.hpp)
• Rolling-Hash (src/String/RollingHash.hpp)

Code

// competitive-verifier: PROBLEM https://yukicoder.me/problems/no/2332
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64
#include <iostream>
#include <vector>
#include "src/Math/ModInt.hpp"
#include "src/Misc/Pointwise.hpp"
#include "src/String/RollingHash.hpp"
#include "src/Misc/rng.hpp"
#include "src/Optimization/LiChaoTree.hpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(0);
 using Mint= ModInt<998244353>;
 using K= Pointwise<Mint, Mint>;
 using RH= RollingHash<K>;
 RH::init({rng(), rng()});
 int N, M;
 cin >> N >> M;
 vector<int> A(N), B(M), C(M);
 for (int i= 0; i < N; ++i) cin >> A[i];
 for (int i= 0; i < M; ++i) cin >> B[i];
 for (int i= 0; i < M; ++i) cin >> C[i];
 RH rha(A), rhb(B);
 auto f= [&](int x, long long a, long long b) { return a * x + b; };
 LiChaoTree lct(f, 0, 1e9 + 10);
 auto tree= lct.make_tree<MINIMIZE>();
 long long ans= 0;
 for (int i= 0; i < M; ++i) {
  if (ans >= 0) tree.insert(C[i], ans - (long long)C[i] * i, i + 1, i + lcp(rha, rhb.sub(i)) + 1);
  auto [a, b]= tree.query(i + 1);
  ans= b < 0 ? -1 : a;
 }
 cout << ans << '\n';
 return 0;
}

#line 1 "test/yukicoder/2332.RH.test.cpp"
// competitive-verifier: PROBLEM https://yukicoder.me/problems/no/2332
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64
#include <iostream>
#include <vector>
#line 2 "src/Math/mod_inv.hpp"
#include <utility>
#include <type_traits>
#include <cassert>
template <class Uint> constexpr inline Uint mod_inv(Uint a, Uint mod) {
 std::make_signed_t<Uint> x= 1, y= 0, z= 0;
 for (Uint q= 0, b= mod, c= 0; b;) z= x, x= y, y= z - y * (q= a / b), c= a, a= b, b= c - b * q;
 return assert(a == 1), x < 0 ? mod - (-x) % mod : x % mod;
}
#line 2 "src/Internal/Remainder.hpp"
namespace math_internal {
using namespace std;
using u8= unsigned char;
using u32= unsigned;
using i64= long long;
using u64= unsigned long long;
using u128= __uint128_t;
struct MP_Na {  // mod < 2^32
 u32 mod;
 constexpr MP_Na(): mod(0) {}
 constexpr MP_Na(u32 m): mod(m) {}
 constexpr inline u32 mul(u32 l, u32 r) const { return u64(l) * r % mod; }
 constexpr inline u32 set(u32 n) const { return n; }
 constexpr inline u32 get(u32 n) const { return n; }
 constexpr inline u32 norm(u32 n) const { return n; }
 constexpr inline u32 plus(u64 l, u32 r) const { return l+= r, l < mod ? l : l - mod; }
 constexpr inline u32 diff(u64 l, u32 r) const { return l-= r, l >> 63 ? l + mod : l; }
};
template <class u_t, class du_t, u8 B> struct MP_Mo {  // mod < 2^32, mod < 2^62
 u_t mod;
 constexpr MP_Mo(): mod(0), iv(0), r2(0) {}
 constexpr MP_Mo(u_t m): mod(m), iv(inv(m)), r2(-du_t(mod) % mod) {}
 constexpr inline u_t mul(u_t l, u_t r) const { return reduce(du_t(l) * r); }
 constexpr inline u_t set(u_t n) const { return mul(n, r2); }
 constexpr inline u_t get(u_t n) const { return n= reduce(n), n >= mod ? n - mod : n; }
 constexpr inline u_t norm(u_t n) const { return n >= mod ? n - mod : n; }
 constexpr inline u_t plus(u_t l, u_t r) const { return l+= r, l < (mod << 1) ? l : l - (mod << 1); }
 constexpr inline u_t diff(u_t l, u_t r) const { return l-= r, l >> (B - 1) ? l + (mod << 1) : l; }
private:
 u_t iv, r2;
 static constexpr u_t inv(u_t n, int e= 6, u_t x= 1) { return e ? inv(n, e - 1, x * (2 - x * n)) : x; }
 constexpr inline u_t reduce(const du_t &w) const { return u_t(w >> B) + mod - ((du_t(u_t(w) * iv) * mod) >> B); }
};
using MP_Mo32= MP_Mo<u32, u64, 32>;
using MP_Mo64= MP_Mo<u64, u128, 64>;
struct MP_Br {  // 2^20 < mod <= 2^41
 u64 mod;
 constexpr MP_Br(): mod(0), x(0) {}
 constexpr MP_Br(u64 m): mod(m), x((u128(1) << 84) / m) {}
 constexpr inline u64 mul(u64 l, u64 r) const { return rem(u128(l) * r); }
 static constexpr inline u64 set(u64 n) { return n; }
 constexpr inline u64 get(u64 n) const { return n >= mod ? n - mod : n; }
 constexpr inline u64 norm(u64 n) const { return n >= mod ? n - mod : n; }
 constexpr inline u64 plus(u64 l, u64 r) const { return l+= r, l < (mod << 1) ? l : l - (mod << 1); }
 constexpr inline u64 diff(u64 l, u64 r) const { return l-= r, l >> 63 ? l + (mod << 1) : l; }
private:
 u64 x;
 constexpr inline u128 quo(const u128 &n) const { return (n * x) >> 84; }
 constexpr inline u64 rem(const u128 &n) const { return n - quo(n) * mod; }
};
template <class du_t, u8 B> struct MP_D2B1 {  // mod < 2^63, mod < 2^64
 u64 mod;
 constexpr MP_D2B1(): mod(0), s(0), d(0), v(0) {}
 constexpr MP_D2B1(u64 m): mod(m), s(__builtin_clzll(m)), d(m << s), v(u128(-1) / d) {}
 constexpr inline u64 mul(u64 l, u64 r) const { return rem((u128(l) * r) << s) >> s; }
 constexpr inline u64 set(u64 n) const { return n; }
 constexpr inline u64 get(u64 n) const { return n; }
 constexpr inline u64 norm(u64 n) const { return n; }
 constexpr inline u64 plus(du_t l, u64 r) const { return l+= r, l < mod ? l : l - mod; }
 constexpr inline u64 diff(du_t l, u64 r) const { return l-= r, l >> B ? l + mod : l; }
private:
 u8 s;
 u64 d, v;
 constexpr inline u64 rem(const u128 &u) const {
  u128 q= (u >> 64) * v + u;
  u64 r= u64(u) - (q >> 64) * d - d;
  if (r > u64(q)) r+= d;
  if (r >= d) r-= d;
  return r;
 }
};
using MP_D2B1_1= MP_D2B1<u64, 63>;
using MP_D2B1_2= MP_D2B1<u128, 127>;
template <class u_t, class MP> constexpr u_t pow(u_t x, u64 k, const MP &md) {
 for (u_t ret= md.set(1);; x= md.mul(x, x))
  if (k & 1 ? ret= md.mul(ret, x) : 0; !(k>>= 1)) return ret;
}
}
#line 3 "src/Internal/modint_traits.hpp"
namespace math_internal {
struct m_b {};
struct s_b: m_b {};
}
template <class mod_t> constexpr bool is_modint_v= std::is_base_of_v<math_internal::m_b, mod_t>;
template <class mod_t> constexpr bool is_staticmodint_v= std::is_base_of_v<math_internal::s_b, mod_t>;
#line 6 "src/Math/ModInt.hpp"
namespace math_internal {
template <class MP, u64 MOD> struct SB: s_b {
protected:
 static constexpr MP md= MP(MOD);
};
template <class U, class B> struct MInt: public B {
 using Uint= U;
 static constexpr inline auto mod() { return B::md.mod; }
 constexpr MInt(): x(0) {}
 template <class T, typename= enable_if_t<is_modint_v<T> && !is_same_v<T, MInt>>> constexpr MInt(T v): x(B::md.set(v.val() % B::md.mod)) {}
 constexpr MInt(__int128_t n): x(B::md.set((n < 0 ? ((n= (-n) % B::md.mod) ? B::md.mod - n : n) : n % B::md.mod))) {}
 constexpr MInt operator-() const { return MInt() - *this; }
#define FUNC(name, op) \
 constexpr MInt name const { \
  MInt ret; \
  return ret.x= op, ret; \
 }
 FUNC(operator+(const MInt & r), B::md.plus(x, r.x))
 FUNC(operator-(const MInt & r), B::md.diff(x, r.x))
 FUNC(operator*(const MInt & r), B::md.mul(x, r.x))
 FUNC(pow(u64 k), math_internal::pow(x, k, B::md))
#undef FUNC
 constexpr MInt operator/(const MInt &r) const { return *this * r.inv(); }
 constexpr MInt &operator+=(const MInt &r) { return *this= *this + r; }
 constexpr MInt &operator-=(const MInt &r) { return *this= *this - r; }
 constexpr MInt &operator*=(const MInt &r) { return *this= *this * r; }
 constexpr MInt &operator/=(const MInt &r) { return *this= *this / r; }
 constexpr bool operator==(const MInt &r) const { return B::md.norm(x) == B::md.norm(r.x); }
 constexpr bool operator!=(const MInt &r) const { return !(*this == r); }
 constexpr bool operator<(const MInt &r) const { return B::md.norm(x) < B::md.norm(r.x); }
 constexpr inline MInt inv() const { return mod_inv<U>(val(), B::md.mod); }
 constexpr inline Uint val() const { return B::md.get(x); }
 friend ostream &operator<<(ostream &os, const MInt &r) { return os << r.val(); }
 friend istream &operator>>(istream &is, MInt &r) {
  i64 v;
  return is >> v, r= MInt(v), is;
 }
private:
 Uint x;
};
template <u64 MOD> using MP_B= conditional_t < (MOD < (1 << 30)) & MOD, MP_Mo32, conditional_t < MOD < (1ull << 32), MP_Na, conditional_t<(MOD < (1ull << 62)) & MOD, MP_Mo64, conditional_t<MOD<(1ull << 41), MP_Br, conditional_t<MOD<(1ull << 63), MP_D2B1_1, MP_D2B1_2>>>>>;
template <u64 MOD> using ModInt= MInt < conditional_t<MOD<(1 << 30), u32, u64>, SB<MP_B<MOD>, MOD>>;
}
using math_internal::ModInt;
#line 2 "src/Misc/Pointwise.hpp"
#include <tuple>
#include <array>
#line 5 "src/Misc/Pointwise.hpp"
template <class... Ks> struct Pointwise: std::tuple<Ks...> {
 static constexpr int N= sizeof...(Ks);
 using Self= Pointwise;
 using std::tuple<Ks...>::tuple;
 template <class T> Pointwise(const T &v) { fill(v, std::make_index_sequence<N>()); }
 template <class T, std::size_t... I> std::array<int, N> fill(const T &v, std::index_sequence<I...>) { return {{(void(std::get<I>(*this)= v), 0)...}}; }
#define HELPER(name, op) \
 template <std::size_t... I> std::array<int, N> name(const Self &y, std::index_sequence<I...>) { return {{(void(std::get<I>(*this) op##= std::get<I>(y)), 0)...}}; } \
 Self &operator op##=(const Self & r) { return name(r, std::make_index_sequence<N>()), *this; }
 HELPER(add_assign, +)
 HELPER(dif_assign, -)
 HELPER(mul_assign, *)
 HELPER(div_assign, /)
#undef HELPER
 Self operator+(const Self &r) const { return Self(*this)+= r; }
 Self operator-(const Self &r) const { return Self(*this)-= r; }
 Self operator*(const Self &r) const { return Self(*this)*= r; }
 Self operator/(const Self &r) const { return Self(*this)/= r; }
};
#line 3 "src/String/RollingHash.hpp"
#include <string>
#line 6 "src/String/RollingHash.hpp"
template <class K, class Int= int> class RollingHash {
 static inline std::vector<K> pw, hsh;
 static inline K bs;
 static inline std::vector<Int> str;
 static inline void set_pw(int n) {
  if (int m= pw.size(); m <= n)
   for (pw.resize(n + 1); m <= n; ++m) pw[m]= pw[m - 1] * bs;
 }
 int bg, n;
 RollingHash(int b, int n): bg(b), n(n) {}
 template <class C> static int bin_srch(int ok, int ng, const C &check) {
  for (int x; ng - ok > 1;) x= (ok + ng) / 2, (check(x) ? ok : ng)= x;
  return ok;
 }
 template <size_t I> static K concat(const std::array<RollingHash, I> &v) {
  K ret= 0;
  for (size_t i= 0; i < I; ++i) ret= ret * pw[v[i].n] + v[i].hash();
  return ret;
 }
public:
 static void init(K b) { bs= b, pw.assign(1, 1), hsh.assign(1, 0); }
 static K base_pow(int i) { return set_pw(i), pw[i]; }
 RollingHash()= default;
 RollingHash(const std::vector<Int> &v): bg(hsh.size() - 1), n(v.size()) {
  str.insert(str.end(), v.begin(), v.end()), set_pw(n), hsh.resize(bg + n + 1);
  for (int i= 0; i < n; ++i) hsh[bg + i + 1]= hsh[bg + i] * bs + v[i];
 }
 RollingHash(const std::string &s): RollingHash(std::vector<Int>(s.begin(), s.end())) {}
 inline size_t length() const { return n; }
 inline K hash() const { return hsh[bg + n] - hsh[bg] * pw[n]; }
 RollingHash sub(int b, int m) const {
  assert(b + m <= n), assert(m >= 0);
  return {bg + b, m};
 }
 RollingHash sub(int b) const {
  assert(b <= n);
  return {bg + b, n - b};
 }
 template <class... Args> friend std::enable_if_t<std::conjunction_v<std::is_same<Args, RollingHash>...>, K> concat_hash(const Args &...rh) { return concat(std::array{rh...}); }
 friend int lcp(const RollingHash &l, const RollingHash &r) {
  return bin_srch(0, std::min(l.n, r.n) + 1, [&](int x) { return l.sub(0, x) == r.sub(0, x); });
 }
 friend int lcs(const RollingHash &l, const RollingHash &r) {
  return bin_srch(0, std::min(l.n, r.n) + 1, [&](int x) { return l.sub(l.n - x) == r.sub(r.n - x); });
 }
 bool operator==(const RollingHash &r) const { return hash() == r.hash(); }
 bool operator!=(const RollingHash &r) const { return !(*this == r); }
 bool operator<(const RollingHash &r) const {
  int k= lcp(*this, r);
  return k == std::min(n, r.n) ? n < r.n : str[bg + k] < str[r.bg + k];
 }
 friend bool concat_cmp(const RollingHash &l, const RollingHash &r) {
  int k= lcp(l, r);
  if (l.n < r.n) {
   if (k < l.n) return str[l.bg + k] < str[r.bg + k];
   if (k= lcp(r, r.sub(l.n)); k < r.n - l.n) return str[r.bg + k] < str[r.bg + l.n + k];
   if (k= lcp(r.sub(r.n - l.n), l); k < l.n) return str[r.bg + r.n - l.n + k] < str[l.bg + k];
  } else {
   if (k < r.n) return str[l.bg + k] < str[r.bg + k];
   if (k= lcp(l.sub(r.n), l); k < l.n - r.n) return str[l.bg + r.n + k] < str[l.bg + k];
   if (k= lcp(r, l.sub(l.n - r.n)); k < r.n) return str[r.bg + k] < str[l.bg + l.n - r.n + k];
  }
  return false;
 }
 std::string to_str() const {  // for debug
  std::string ret;
  for (int i= bg; i < bg + n; ++i) ret+= (char)str[i];
  return ret;
 }
};
#line 2 "src/Misc/rng.hpp"
#include <random>
#include <cstdint>
uint64_t rng() {
 static uint64_t x= 10150724397891781847ULL * std::random_device{}();
 return x^= x << 7, x^= x >> 9;
}
uint64_t rng(uint64_t lim) { return rng() % lim; }
int64_t rng(int64_t l, int64_t r) { return l + rng() % (r - l); }
#line 2 "src/Optimization/LiChaoTree.hpp"
#include <limits>
#include <algorithm>
#line 3 "src/Internal/function_traits.hpp"
// clang-format off
namespace function_template_internal{
template<class C>struct is_function_object{
 template<class U,int dummy=(&U::operator(),0)> static std::true_type check(U *);
 static std::false_type check(...);
 static C *m;
 static constexpr bool value= decltype(check(m))::value;
};
template<class F,bool,bool>struct function_type_impl{using type= void;};
template<class F>struct function_type_impl<F,true,false>{using type= F *;};
template<class F>struct function_type_impl<F,false,true>{using type= decltype(&F::operator());};
template<class F> using function_type_t= typename function_type_impl<F,std::is_function_v<F>,is_function_object<F>::value>::type;
template<class... Args>struct result_type_impl{using type= void;};
template<class R,class... Args>struct result_type_impl<R(*)(Args...)>{using type= R;};
template<class C,class R,class... Args>struct result_type_impl<R(C::*)(Args...)>{using type= R;};
template<class C,class R,class... Args>struct result_type_impl<R(C::*)(Args...)const>{using type= R;};
template<class F> using result_type_t= typename result_type_impl<function_type_t<F>>::type;
template<class... Args>struct argument_type_impl{using type= void;};
template<class R,class... Args>struct argument_type_impl<R(*)(Args...)>{using type= std::tuple<Args...>;};
template<class C,class R,class... Args>struct argument_type_impl<R(C::*)(Args...)>{using type= std::tuple<Args...>;};
template<class C,class R,class... Args>struct argument_type_impl<R(C::*)(Args...)const>{using type= std::tuple<Args...>;};
template<class F> using argument_type_t= typename argument_type_impl<function_type_t<F>>::type;
}
using function_template_internal::result_type_t,function_template_internal::argument_type_t;
// clang-format on
#line 2 "src/Optimization/MinMaxEnum.hpp"
enum MinMaxEnum { MAXIMIZE= -1, MINIMIZE= 1 };
#line 9 "src/Optimization/LiChaoTree.hpp"
template <class F, class T> class LiChaoTree {};
template <class F, class T, class... Prms> class LiChaoTree<F, std::tuple<T, Prms...>> {
 using R= result_type_t<F>;
 F f;
 const T LB, UB;
 std::vector<std::tuple<Prms...>> ps;
 template <MinMaxEnum sgn, bool persistent> class LiChaoTreeInterface {
  LiChaoTree *ins;
  struct Node {
   int id= -1;
   Node *ch[2]= {nullptr, nullptr};
  } *root;
  inline R eval(int id, T x) const { return std::apply(ins->f, std::tuple_cat(std::make_tuple(x), ins->ps[id])); }
  static inline bool cmp(const R &p, const R &n, int pi, int ni) {
   if constexpr (sgn == MINIMIZE) return p > n || (p == n && pi > ni);
   else return p < n || (p == n && pi > ni);
  }
  inline bool cmp(T x, int pi, int ni) const {
   if (ni == -1) return false;
   if (pi == -1) return true;
   return cmp(eval(pi, x), eval(ni, x), pi, ni);
  }
  static inline T ub(T r) {
   if constexpr (std::is_floating_point_v<T>) return r;
   else return r - 1;
  }
  inline void addl(Node *&t, int id, T xl, T xr) {
   if (!t) return t= new Node{id}, void();
   bool bl= cmp(xl, t->id, id), br= cmp(ub(xr), t->id, id);
   if (!bl && !br) return;
   if constexpr (persistent) t= new Node(*t);
   if (bl && br) return t->id= id, void();
   T xm= (xl + xr) / 2;
   if (cmp(xm, t->id, id)) std::swap(t->id, id), bl= !bl;
   if constexpr (std::is_floating_point_v<T>)
    if (xr - xl < 1e-9) return;
   bl ? addl(t->ch[0], id, xl, xm) : addl(t->ch[1], id, xm, xr);
  }
  inline void adds(Node *&t, int id, T l, T r, T xl, T xr) {
   if (r <= xl || xr <= l) return;
   if (l <= xl && xr <= r) return addl(t, id, xl, xr);
   if (!t) t= new Node;
   else if constexpr (persistent) t= new Node(*t);
   T xm= (xl + xr) / 2;
   adds(t->ch[0], id, l, r, xl, xm), adds(t->ch[1], id, l, r, xm, xr);
  }
  inline std::pair<R, int> query(const Node *t, T x, T xl, T xr) const {
   if (!t) return {R(), -1};
   T xm= (xl + xr) / 2;
   auto b= x < xm ? query(t->ch[0], x, xl, xm) : query(t->ch[1], x, xm, xr);
   if (t->id == -1) return b;
   R a= eval(t->id, x);
   return b.second != -1 && cmp(a, b.first, t->id, b.second) ? b : std::make_pair(a, t->id);
  }
 public:
  LiChaoTreeInterface()= default;
  LiChaoTreeInterface(LiChaoTree *ins): ins(ins), root(nullptr) {}
  void insert(const Prms &...args) { ins->ps.emplace_back(args...), addl(root, ins->ps.size() - 1, ins->LB, ins->UB); }
  // [l, r)
  void insert(const Prms &...args, T l, T r) {
   l= std::max(l, ins->LB), r= std::min(r, ins->UB);
   if (l < r) ins->ps.emplace_back(args...), adds(root, ins->ps.size() - 1, l, r, ins->LB, ins->UB);
  }
  // [l, UB)
  void insert(const Prms &...args, T l) { insert(args..., l, ins->UB); }
  std::pair<R, int> query(T x) const { return assert(ins->LB <= x && x < ins->UB), query(root, x, ins->LB, ins->UB); }
  const std::tuple<Prms...> &params(int id) const { return ins->ps[id]; }
 };
public:
 LiChaoTree(const F &f, T LB= -2e9, T UB= 2e9): f(f), LB(LB), UB(UB) {}
 template <MinMaxEnum sgn= MINIMIZE, bool persistent= false> LiChaoTreeInterface<sgn, persistent> make_tree() { return this; }
};
template <class F, class T, class U> LiChaoTree(F, T, U) -> LiChaoTree<F, argument_type_t<F>>;
template <class F, class T> LiChaoTree(F, T) -> LiChaoTree<F, argument_type_t<F>>;
template <class F> LiChaoTree(F) -> LiChaoTree<F, argument_type_t<F>>;
#line 11 "test/yukicoder/2332.RH.test.cpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(0);
 using Mint= ModInt<998244353>;
 using K= Pointwise<Mint, Mint>;
 using RH= RollingHash<K>;
 RH::init({rng(), rng()});
 int N, M;
 cin >> N >> M;
 vector<int> A(N), B(M), C(M);
 for (int i= 0; i < N; ++i) cin >> A[i];
 for (int i= 0; i < M; ++i) cin >> B[i];
 for (int i= 0; i < M; ++i) cin >> C[i];
 RH rha(A), rhb(B);
 auto f= [&](int x, long long a, long long b) { return a * x + b; };
 LiChaoTree lct(f, 0, 1e9 + 10);
 auto tree= lct.make_tree<MINIMIZE>();
 long long ans= 0;
 for (int i= 0; i < M; ++i) {
  if (ans >= 0) tree.insert(C[i], ans - (long long)C[i] * i, i + 1, i + lcp(rha, rhb.sub(i)) + 1);
  auto [a, b]= tree.query(i + 1);
  ans= b < 0 ? -1 : a;
 }
 cout << ans << '\n';
 return 0;
}

Test cases

Env	Name	Status	Elapsed	Memory
g++-13	sample_1.txt	AC	6 ms	4 MB
g++-13	sample_2.txt	AC	5 ms	4 MB
g++-13	test_1.txt	AC	5 ms	4 MB
g++-13	test_10.txt	AC	43 ms	7 MB
g++-13	test_11.txt	AC	85 ms	13 MB
g++-13	test_12.txt	AC	86 ms	13 MB
g++-13	test_13.txt	AC	85 ms	13 MB
g++-13	test_14.txt	AC	85 ms	13 MB
g++-13	test_15.txt	AC	86 ms	13 MB
g++-13	test_16.txt	AC	85 ms	13 MB
g++-13	test_17.txt	AC	85 ms	13 MB
g++-13	test_18.txt	AC	86 ms	13 MB
g++-13	test_19.txt	AC	86 ms	13 MB
g++-13	test_2.txt	AC	5 ms	4 MB
g++-13	test_20.txt	AC	86 ms	13 MB
g++-13	test_21.txt	AC	86 ms	13 MB
g++-13	test_22.txt	AC	91 ms	13 MB
g++-13	test_23.txt	AC	88 ms	13 MB
g++-13	test_24.txt	AC	87 ms	13 MB
g++-13	test_25.txt	AC	88 ms	13 MB
g++-13	test_26.txt	AC	91 ms	13 MB
g++-13	test_27.txt	AC	90 ms	13 MB
g++-13	test_28.txt	AC	91 ms	13 MB
g++-13	test_29.txt	AC	90 ms	13 MB
g++-13	test_3.txt	AC	5 ms	4 MB
g++-13	test_30.txt	AC	90 ms	13 MB
g++-13	test_31.txt	AC	102 ms	16 MB
g++-13	test_32.txt	AC	102 ms	16 MB
g++-13	test_33.txt	AC	102 ms	16 MB
g++-13	test_34.txt	AC	101 ms	16 MB
g++-13	test_35.txt	AC	102 ms	16 MB
g++-13	test_36.txt	AC	99 ms	16 MB
g++-13	test_37.txt	AC	101 ms	16 MB
g++-13	test_38.txt	AC	103 ms	17 MB
g++-13	test_39.txt	AC	100 ms	15 MB
g++-13	test_4.txt	AC	5 ms	4 MB
g++-13	test_40.txt	AC	98 ms	15 MB
g++-13	test_41.txt	AC	129 ms	22 MB
g++-13	test_42.txt	AC	128 ms	22 MB
g++-13	test_43.txt	AC	125 ms	22 MB
g++-13	test_44.txt	AC	130 ms	23 MB
g++-13	test_45.txt	AC	129 ms	23 MB
g++-13	test_46.txt	AC	169 ms	25 MB
g++-13	test_47.txt	AC	170 ms	25 MB
g++-13	test_48.txt	AC	170 ms	24 MB
g++-13	test_49.txt	AC	169 ms	24 MB
g++-13	test_5.txt	AC	5 ms	3 MB
g++-13	test_50.txt	AC	168 ms	25 MB
g++-13	test_51.txt	AC	94 ms	13 MB
g++-13	test_52.txt	AC	91 ms	13 MB
g++-13	test_53.txt	AC	90 ms	13 MB
g++-13	test_54.txt	AC	92 ms	13 MB
g++-13	test_55.txt	AC	93 ms	13 MB
g++-13	test_56.txt	AC	55 ms	13 MB
g++-13	test_57.txt	AC	52 ms	13 MB
g++-13	test_58.txt	AC	54 ms	13 MB
g++-13	test_59.txt	AC	54 ms	13 MB
g++-13	test_6.txt	AC	72 ms	11 MB
g++-13	test_60.txt	AC	52 ms	13 MB
g++-13	test_61.txt	AC	148 ms	24 MB
g++-13	test_7.txt	AC	21 ms	10 MB
g++-13	test_8.txt	AC	56 ms	11 MB
g++-13	test_9.txt	AC	61 ms	9 MB
clang++-18	sample_1.txt	AC	5 ms	4 MB
clang++-18	sample_2.txt	AC	4 ms	4 MB
clang++-18	test_1.txt	AC	5 ms	4 MB
clang++-18	test_10.txt	AC	44 ms	7 MB
clang++-18	test_11.txt	AC	87 ms	13 MB
clang++-18	test_12.txt	AC	87 ms	13 MB
clang++-18	test_13.txt	AC	90 ms	13 MB
clang++-18	test_14.txt	AC	87 ms	13 MB
clang++-18	test_15.txt	AC	87 ms	13 MB
clang++-18	test_16.txt	AC	88 ms	13 MB
clang++-18	test_17.txt	AC	87 ms	13 MB
clang++-18	test_18.txt	AC	87 ms	13 MB
clang++-18	test_19.txt	AC	87 ms	13 MB
clang++-18	test_2.txt	AC	5 ms	4 MB
clang++-18	test_20.txt	AC	87 ms	13 MB
clang++-18	test_21.txt	AC	90 ms	13 MB
clang++-18	test_22.txt	AC	90 ms	13 MB
clang++-18	test_23.txt	AC	90 ms	13 MB
clang++-18	test_24.txt	AC	91 ms	13 MB
clang++-18	test_25.txt	AC	89 ms	13 MB
clang++-18	test_26.txt	AC	95 ms	13 MB
clang++-18	test_27.txt	AC	93 ms	13 MB
clang++-18	test_28.txt	AC	94 ms	13 MB
clang++-18	test_29.txt	AC	93 ms	13 MB
clang++-18	test_3.txt	AC	5 ms	4 MB
clang++-18	test_30.txt	AC	93 ms	13 MB
clang++-18	test_31.txt	AC	105 ms	16 MB
clang++-18	test_32.txt	AC	105 ms	16 MB
clang++-18	test_33.txt	AC	105 ms	16 MB
clang++-18	test_34.txt	AC	106 ms	16 MB
clang++-18	test_35.txt	AC	105 ms	16 MB
clang++-18	test_36.txt	AC	103 ms	15 MB
clang++-18	test_37.txt	AC	103 ms	16 MB
clang++-18	test_38.txt	AC	107 ms	17 MB
clang++-18	test_39.txt	AC	102 ms	15 MB
clang++-18	test_4.txt	AC	5 ms	4 MB
clang++-18	test_40.txt	AC	99 ms	15 MB
clang++-18	test_41.txt	AC	131 ms	22 MB
clang++-18	test_42.txt	AC	130 ms	22 MB
clang++-18	test_43.txt	AC	128 ms	22 MB
clang++-18	test_44.txt	AC	133 ms	23 MB
clang++-18	test_45.txt	AC	132 ms	23 MB
clang++-18	test_46.txt	AC	197 ms	25 MB
clang++-18	test_47.txt	AC	196 ms	25 MB
clang++-18	test_48.txt	AC	196 ms	24 MB
clang++-18	test_49.txt	AC	196 ms	25 MB
clang++-18	test_5.txt	AC	5 ms	4 MB
clang++-18	test_50.txt	AC	196 ms	24 MB
clang++-18	test_51.txt	AC	95 ms	13 MB
clang++-18	test_52.txt	AC	93 ms	13 MB
clang++-18	test_53.txt	AC	92 ms	13 MB
clang++-18	test_54.txt	AC	95 ms	13 MB
clang++-18	test_55.txt	AC	96 ms	13 MB
clang++-18	test_56.txt	AC	62 ms	13 MB
clang++-18	test_57.txt	AC	58 ms	13 MB
clang++-18	test_58.txt	AC	61 ms	13 MB
clang++-18	test_59.txt	AC	60 ms	13 MB
clang++-18	test_6.txt	AC	73 ms	11 MB
clang++-18	test_60.txt	AC	58 ms	13 MB
clang++-18	test_61.txt	AC	156 ms	24 MB
clang++-18	test_7.txt	AC	23 ms	10 MB
clang++-18	test_8.txt	AC	58 ms	11 MB
clang++-18	test_9.txt	AC	63 ms	9 MB

Back to top page