matsutaku-library

This documentation is automatically generated by competitive-verifier/competitive-verifier

View the Project on GitHub MatsuTaku/matsutaku-library

:heavy_check_mark: test/aoj/aoj-do_use_segment_tree-binary_tree.test.cpp

Code

#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/problems/2450"
#include "include/mtl/lazy_segment_tree.hpp"
#include "include/mtl/hld.hpp"
#include <bits/stdc++.h>

using namespace std;

constexpr int MINF = -1e9;
struct M {
  int l,r,sum,v,sz;
  M() : v(MINF), sz(0) {}
  M(int w) : l(w),r(w),sum(w),v(w), sz(1) {}
  friend M operator*(const M& lhs, const M& rhs) {
    if (lhs.v == MINF) return rhs;
    if (rhs.v == MINF) return lhs;
    M ret;
    ret.l = max(lhs.l, lhs.sum + rhs.l);
    ret.r = max(rhs.r, lhs.r + rhs.sum);
    ret.v = max({lhs.v, rhs.v, lhs.r + rhs.l});
    ret.sum = lhs.sum + rhs.sum;
    ret.sz = lhs.sz + rhs.sz;
    return ret;
  }
};
struct A {
  int v;
  bool f;
  A() : f(false) {}
  A(int v) : v(v), f(true) {}
  bool operator()() const { return f; }
  A& operator*=(const A& r) {
    if (r.f) *this = r;
    return *this;
  }
  M act(const M& m) const {
    if (!f) return m;
    M ret = m;
    ret.sum = v*m.sz;
    ret.l = ret.r = ret.v = (v >= 0 ? ret.sum : v);
    return ret;
  }
};

int main() {
  int n,q; cin>>n>>q;
  vector<int> W(n);
  for (auto& w:W) cin>>w;
  Hld T(n);
  for (int i = 0; i < n-1; i++) {
    int s,e; cin>>s>>e; s--; e--;
    T.add_edge(s,e);
  }
  T.build();
  vector<int> X(n*2);
  for (int i = 0; i < n; i++)
    X[T.in[i]] = X[n+n-1-T.in[i]] = W[i];
  SegmentTreebase<M,A> RQ(X.begin(), X.end());
  auto range_update = [&](int l, int r, int v) {
    RQ.update(l,r,v);
    RQ.update(n+n-r, n+n-l, v);
  };
  auto query = [&](int l, int r) {
    return RQ.query(l,r);
  };
  auto reverse_query = [&](int l, int r) {
    return RQ.query(n+n-r, n+n-l);
  };
  for (int i = 0; i < q; i++) {
    int t; cin>>t;
    if (t == 1) {
      int a,b,c; cin>>a>>b>>c; a--; b--;
      T.update(a,b,range_update,c);
    } else if (t == 2) {
      int a,b,c; cin>>a>>b>>c; a--; b--;
      cout << T.query(a,b,query,reverse_query).v << endl;
    }
  }
}
#line 1 "test/aoj/aoj-do_use_segment_tree-binary_tree.test.cpp"
#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/problems/2450"
#line 2 "include/mtl/bit_manip.hpp"
#include <cstdint>
#include <cassert>
#if __cplusplus >= 202002L
#ifndef MTL_CPP20
#define MTL_CPP20
#endif
#include <bit>
#endif

namespace bm {

/// Count 1s for each 8 bits
inline constexpr uint64_t popcnt_e8(uint64_t x) {
  x = (x & 0x5555555555555555) + ((x>>1) & 0x5555555555555555);
  x = (x & 0x3333333333333333) + ((x>>2) & 0x3333333333333333);
  x = (x & 0x0F0F0F0F0F0F0F0F) + ((x>>4) & 0x0F0F0F0F0F0F0F0F);
  return x;
}
/// Count 1s
inline constexpr unsigned popcnt(uint64_t x) {
#ifdef MTL_CPP20
  return std::popcount(x);
#else
  return (popcnt_e8(x) * 0x0101010101010101) >> 56;
#endif
}
/// Alias to mtl::popcnt(x)
constexpr unsigned popcount(uint64_t x) {
  return popcnt(x);
}
/// Count trailing 0s. s.t. *11011000 -> 3
inline constexpr unsigned ctz(uint64_t x) {
#ifdef MTL_CPP20
  return std::countr_zero(x);
#else
  return popcnt((x & (-x)) - 1);
#endif
}
/// Alias to mtl::ctz(x)
constexpr unsigned countr_zero(uint64_t x) {
  return ctz(x);
}
/// Count trailing 1s. s.t. *11011011 -> 2
inline constexpr unsigned cto(uint64_t x) {
#ifdef MTL_CPP20
  return std::countr_one(x);
#else
  return ctz(~x);
#endif
}
/// Alias to mtl::cto(x)
constexpr unsigned countr_one(uint64_t x) {
  return cto(x);
}
inline constexpr unsigned ctz8(uint8_t x) {
  return x == 0 ? 8 : popcnt_e8((x & (-x)) - 1);
}
/// [00..0](8bit) -> 0, [**..*](not only 0) -> 1
inline constexpr uint8_t summary(uint64_t x) {
  constexpr uint64_t hmask = 0x8080808080808080ull;
  constexpr uint64_t lmask = 0x7F7F7F7F7F7F7F7Full;
  auto a = x & hmask;
  auto b = x & lmask;
  b = hmask - b;
  b = ~b;
  auto c = (a | b) & hmask;
  c *= 0x0002040810204081ull;
  return uint8_t(c >> 56);
}
/// Extract target area of bits
inline constexpr uint64_t bextr(uint64_t x, unsigned start, unsigned len) {
  uint64_t mask = len < 64 ? (1ull<<len)-1 : 0xFFFFFFFFFFFFFFFFull;
  return (x >> start) & mask;
}
/// 00101101 -> 00111111 -count_1s-> 6
inline constexpr unsigned log2p1(uint8_t x) {
  if (x & 0x80)
    return 8;
  uint64_t p = uint64_t(x) * 0x0101010101010101ull;
  p -= 0x8040201008040201ull;
  p = ~p & 0x8080808080808080ull;
  p = (p >> 7) * 0x0101010101010101ull;
  p >>= 56;
  return p;
}
/// 00101100 -mask_mssb-> 00100000 -to_index-> 5
inline constexpr unsigned mssb8(uint8_t x) {
  assert(x != 0);
  return log2p1(x) - 1;
}
/// 00101100 -mask_lssb-> 00000100 -to_index-> 2
inline constexpr unsigned lssb8(uint8_t x) {
  assert(x != 0);
  return popcnt_e8((x & -x) - 1);
}
/// Count leading 0s. 00001011... -> 4
inline constexpr unsigned clz(uint64_t x) {
#ifdef MTL_CPP20
  return std::countl_zero(x);
#else
  if (x == 0)
    return 64;
  auto i = mssb8(summary(x));
  auto j = mssb8(bextr(x, 8 * i, 8));
  return 63 - (8 * i + j);
#endif
}
/// Alias to mtl::clz(x)
constexpr unsigned countl_zero(uint64_t x) {
  return clz(x);
}
/// Count leading 1s. 11110100... -> 4
inline constexpr unsigned clo(uint64_t x) {
#ifdef MTL_CPP20
  return std::countl_one(x);
#else
  return clz(~x);
#endif
}
/// Alias to mtl::clo(x)
constexpr unsigned countl_one(uint64_t x) {
  return clo(x);
}

inline constexpr unsigned clz8(uint8_t x) {
  return x == 0 ? 8 : 7 - mssb8(x);
}
inline constexpr uint64_t bit_reverse(uint64_t x) {
  x = ((x & 0x00000000FFFFFFFF) << 32) | ((x & 0xFFFFFFFF00000000) >> 32);
  x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x & 0xFFFF0000FFFF0000) >> 16);
  x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x & 0xFF00FF00FF00FF00) >> 8);
  x = ((x & 0x0F0F0F0F0F0F0F0F) << 4) | ((x & 0xF0F0F0F0F0F0F0F0) >> 4);
  x = ((x & 0x3333333333333333) << 2) | ((x & 0xCCCCCCCCCCCCCCCC) >> 2);
  x = ((x & 0x5555555555555555) << 1) | ((x & 0xAAAAAAAAAAAAAAAA) >> 1);
  return x;
}

/// Check if x is power of 2. 00100000 -> true, 00100001 -> false
constexpr bool has_single_bit(uint64_t x) noexcept {
#ifdef MTL_CPP20
  return std::has_single_bit(x);
#else
  return x != 0 && (x & (x - 1)) == 0;
#endif
}

/// Bit width needs to represent x. 00110110 -> 6
constexpr int bit_width(uint64_t x) noexcept {
#ifdef MTL_CPP20
  return std::bit_width(x);
#else
  return 64 - clz(x);
#endif
}

/// Ceil power of 2. 00110110 -> 01000000
constexpr uint64_t bit_ceil(uint64_t x) {
#ifdef MTL_CPP20
  return std::bit_ceil(x);
#else
  if (x == 0) return 1;
  return 1ull << bit_width(x - 1);
#endif
}

/// Floor power of 2. 00110110 -> 00100000
constexpr uint64_t bit_floor(uint64_t x) {
#ifdef MTL_CPP20
  return std::bit_floor(x);
#else
  if (x == 0) return 0;
  return 1ull << (bit_width(x) - 1);
#endif
}

} // namespace bm
#line 3 "include/mtl/lazy_segment_tree.hpp"
// #include "monoid.hpp"
#include <cstddef>
#include <utility>
#include <vector>
#include <stack>
#line 9 "include/mtl/lazy_segment_tree.hpp"
#if __cpp_concepts >= 202002L
#include <concepts>

template<typename M>
concept LazySegmentTreeMonoid = requires (M m) {
  {m * m} -> std::same_as<M>;
};
template<typename A, typename M>
concept LazySegmentTreeOperatorMonoid = requires(A a, M m) {
  {a *= a} -> std::same_as<A&>;
  {a.act(m)} -> std::same_as<M>;
};
#endif

template <typename M, typename A>
#if __cpp_concepts >= 202002L
requires LazySegmentTreeMonoid<M> &&
         LazySegmentTreeOperatorMonoid<A,M>
#endif
class SegmentTreebase {
 private:
  size_t size_;
  std::vector<std::pair<M, A>> tree_;
  std::vector<size_t> ids_;

 public:
  explicit SegmentTreebase(size_t size) :
      size_(1ull<<(64-bm::clz(size-1))),
      tree_(size_*2) {
    ids_.reserve((64-bm::clz(size-1))*2);
  }

  template <typename Iter>
  explicit SegmentTreebase(Iter begin, Iter end)
    : SegmentTreebase(std::distance(begin, end)) {
    static_assert(std::is_convertible<typename std::iterator_traits<Iter>::value_type, M>::value, "");
    for (auto it = begin; it != end; ++it) {
      tree_[size_ + it - begin].first = *it;
    }
    for (size_t i = size_-1; i > 0; i--) {
      tree_[i].first = tree_[i*2].first * tree_[i*2+1].first;
    }
  }

  inline void range_update(size_t l, size_t r, const A& e) {
    assert(l <= r);
    assert(r <= size_);
    if (l == r) return;
    _lazy_propagation(l, r);

    for (size_t _l=l+size_, _r=r+size_; _l<_r; _l>>=1, _r>>=1) {
      if (_l&1) 
        tree_[_l++].second *= e;
      if (_r&1) 
        tree_[--_r].second *= e;
    }

    for (auto id : ids_) {
      _propagate(id*2);
      _propagate(id*2+1);
      tree_[id].first = tree_[id*2].first * tree_[id*2+1].first;
    }
  }
  inline void update(size_t l, size_t r, const A& e) {
    range_update(l, r, e);
  }
  inline void update(size_t i, const A& e) {
    range_update(i, i+1, e);
  }

  template<typename T>
  inline void set(size_t i, T&& e) {
    _lazy_propagation(i, i+1);
    int u = i+size_;
    tree_[u].first = M(std::forward<T>(e));
    u >>= 1;
    while (u > 0) {
      tree_[u].first = tree_[u*2].first * tree_[u*2+1].first;
      u >>= 1;
    }
  }

  inline M query(size_t l, size_t r) {
    _lazy_propagation(l, r);

    M lhs,rhs;
    for (size_t _l=l+size_, _r=r+size_; _l<_r; _l>>=1, _r>>=1) {
      if (_l&1) {
        _propagate(_l);
        lhs = lhs * tree_[_l].first;
        ++_l;
      }
      if (_r&1) {
        --_r;
        _propagate(_r);
        rhs = tree_[_r].first * rhs;
      }
    }
    return lhs * rhs;
  }
  /// Alias for query(l, r)
  M prod(size_t l, size_t r) {
    return query(l, r);
  }

  inline const M& get(size_t index) {
    _lazy_propagation(index, index+1);
    auto l = index+size_;
    _propagate(l);
    return tree_[l].first;
  }

 private:
  void _set_ids(size_t l, size_t r) {
    ids_.clear();
    auto _l=l+size_, _r=r+size_;
    auto lth = _l/(_l&(-_l))/2;
    auto rth = _r/(_r&(-_r))/2;
    for (; _l<_r; _l>>=1, _r>>=1) {
      if (_r <= rth) ids_.push_back(_r);
      if (_l <= lth) ids_.push_back(_l);
    }
    for (; _l>0; _l>>=1)
      ids_.push_back(_l);
  }

  inline void _propagate(size_t id) {
    A& e = tree_[id].second;
    tree_[id].first = e.act(tree_[id].first);
    if (id < size_) {
      tree_[id*2].second *= e;
      tree_[id*2+1].second *= e;
    }
    tree_[id].second = A();
  }

  void _lazy_propagation(size_t l, size_t r) {
    if (l == r) return;
    _set_ids(l, r);
    for (auto it = ids_.rbegin(); it != ids_.rend(); ++it)
      _propagate(*it);
  }

 public:
  template<class F>
  size_t max_right(size_t begin, size_t end, F f) {
    if (begin == end) return end;
    M p;
    std::stack<std::pair<size_t, M>> rps;
    auto l = size_ + begin;
    auto r = size_ + end;
    _lazy_propagation(begin, end);
    auto access = [&](size_t i) {
      _propagate(i);
      return tree_[i].first;
    };
    while (l < r and f(p * access(l))) {
      if (l&1) p = p * tree_[l++].first;
      if (r&1) {
        rps.emplace(r, access(r-1));
        r--;
      }
      l>>=1; r>>=1;
    }
    if (l >= r) {
      while (rps.size()) {
        auto& [r, rp] = rps.top();
        if (!f(p * rp)) {
          l = r-1;
          break;
        }
        p = p * rp;
        rps.pop();
      }
      if (rps.empty()) return end;
    }
    while (l < size_) {
      assert(!f(p * access(l)));
      l <<= 1;
      auto pl = access(l);
      if (f(p * pl)) {
        p = p * pl;
        l++;
      }
    }
    return l - size_;
  }
  template<bool (*F)(M)>
  size_t max_right(size_t begin, size_t end) {
    return max_right(begin, end, [](M x) { return F(x); });
  }

  template<class F>
  size_t min_left(size_t begin, size_t end, F f) {
    if (end == begin) return begin;
    M p;
    std::stack<std::pair<size_t, M>> lps;
    auto l = size_ + begin;
    auto r = size_ + end;
    _lazy_propagation(begin, end);
    auto access = [&](size_t i) {
      _propagate(i);
      return tree_[i].first;
    };
    while (l < r and f(access(r-1) * p)) {
      if (l&1) {
        lps.emplace(l, access(l));
        l++;
      }
      if (r&1) p = tree_[r-1].first * p;
      l>>=1; r>>=1;
    }
    if (l >= r) {
      while (lps.size()) {
        auto& [l, lp] = lps.top();
        if (!f(lp * p)) {
          r = l+1;
          break;
        }
        p = lp * p;
        lps.pop();
      }
      if (lps.empty()) return begin;
    }
    while (r <= size_) {
      assert(!f(access(r-1) * p));
      r <<= 1;
      auto pr = access(r-1);
      if (f(pr * p)) {
        p = pr * p;
        --r;
      }
    }
    return r - size_;
  }
  template<bool (*F)(M)>
  size_t min_left(size_t begin, size_t end) {
    return min_left(begin, [](M x) { return F(x); });
  }

};

#line 4 "include/mtl/hld.hpp"

struct Hld {
  int r,n;
  std::vector<std::vector<int>> edge;
  std::vector<int> size, in, out, head, rev, par, depth, clen;
 private:
  void dfs_sz(int v, int p, int d) {
    par[v] = p;
    size[v] = 1;
    if (!edge[v].empty() and edge[v][0] == p)
      std::swap(edge[v][0], edge[v].back());
    for (auto& t:edge[v]) {
      if (t == p) continue;
      dfs_sz(t, v, d+1);
      size[v] += size[t];
      if (size[edge[v][0]] < size[t])
        std::swap(edge[v][0], t);
    }
  }
  void dfs_hld(int v, int p, int& times) {
    in[v] = times++;
    rev[in[v]] = v;
    clen[v] = 1;
    if (!edge[v].empty() and edge[v][0] != p) {
      int t = edge[v][0];
      head[t] = head[v];
      depth[t] = depth[v];
      dfs_hld(t, v, times);
      clen[v] += clen[t];
    }
    for (size_t i = 1; i < edge[v].size(); i++) {
      int t = edge[v][i];
      if (t == p) continue;
      head[t] = t;
      depth[t] = depth[v] + 1;
      dfs_hld(t, v, times);
    }
    out[v] = times;
  }

 public:
  Hld(int n) : r(0), n(n), edge(n), size(n), in(n, -1), out(n, -1), head(n, -1), rev(n, -1), par(n, -1), depth(n, -1), clen(n) {}

  inline void add_edge(int a, int b) {
    edge[a].push_back(b);
    edge[b].push_back(a);
  }

  void build(int root = 0) {
    r = root;
    dfs_sz(root, -1, 0);
    int t = 0;
    head[root] = root;
    depth[root] = 0;
    dfs_hld(root, -1, t);
  }

  inline int lca(int a, int b) const {
    if (depth[a] > depth[b]) std::swap(a, b);
    while (depth[a] < depth[b]) {
      b = par[head[b]];
    }
    while (head[a] != head[b]) {
      a = par[head[a]];
      b = par[head[b]];
    }
    return in[a] < in[b] ? a : b;
  }

 private:
  template<class Query, class ReverseQuery>
  auto _query(int u, int v, Query Q, ReverseQuery RQ, bool include_lca) const -> decltype(Q(0,0)) {
    using T = decltype(Q(0,0));
    T um, vm;
    auto u_up = [&]() {
      um = um * (T)RQ(in[head[u]], in[u]+1);
      u = par[head[u]];
    };
    auto v_up = [&]() {
      vm = (T)Q(in[head[v]], in[v]+1) * vm;
      v = par[head[v]];
    };
    while (depth[u] > depth[v])
      u_up();
    while (depth[u] < depth[v])
      v_up();
    while (head[u] != head[v]) {
      u_up();
      v_up();
    }
    if (in[u] < in[v]) {
      int l = include_lca ? in[u] : in[u]+1;
      return um * (T)Q(l, in[v]+1) * vm;
    } else {
      int l = include_lca ? in[v] : in[v]+1;
      return um * (T)RQ(l, in[u]+1) * vm;
    }
  }

 public:
  template<class Query, class ReverseQuery>
  auto query(int u, int v, Query Q, ReverseQuery RQ, bool include_lca = true) const -> decltype(Q(0,0)) {
    return _query(u, v, Q, RQ, include_lca);
  }

  /// Query for commutative monoid
  template<class Query>
  auto query(int u, int v, Query Q, bool include_lca = true) const -> decltype(Q(0,0)) {
    return _query(u, v, Q, Q, include_lca);
  }

  template<class Set, class T>
  void set(int i, Set S, T&& val) const {
    S(in[i], std::forward<T>(val));
  }

  template<typename Upd, typename T>
  void update(int u, int v, Upd U, const T& val, bool include_lca = true) const {
    if (depth[u] > depth[v]) std::swap(u,v);
    auto up = [&](int& v) {
      U(in[head[v]], in[v]+1, val);
      v = par[head[v]];
    };
    while (depth[u] < depth[v]) {
      up(v);
    }
    while (head[u] != head[v]) {
      up(u);
      up(v);
    }
    if (in[u] > in[v]) std::swap(u,v);
    int l = include_lca ? in[u] : in[u]+1;
    U(l, in[v]+1, val);
  }

public:
  template<class Add, class Sum>
  void subtree_build(Add A, Sum S) const {
    dfs_subtree_build(A, S, r);
  }
 private:
  template<class Add, class Sum>
  void dfs_subtree_build(Add A, Sum S, int u) const {
    for (size_t i = 0; i < edge[u].size(); i++) {
      auto v = edge[u][i];
      if (v == par[u]) continue;
      dfs_subtree_build(A, S, v);
      if (i > 0)
        A(in[u], S(in[v], in[v]+clen[v]));
    }
  }
 public:
  template<class T, class Sum>
  T subtree_sum(int r, Sum S) const {
    return (T)S(in[r], in[r]+clen[r]);
  }
  template<class T, class Add>
  void subtree_point_add(int u, Add A, const T& val) const {
    while (u != -1) {
      A(in[u], val);
      u = par[head[u]];
    }
  }
};
#line 4 "test/aoj/aoj-do_use_segment_tree-binary_tree.test.cpp"
#include <bits/stdc++.h>

using namespace std;

constexpr int MINF = -1e9;
struct M {
  int l,r,sum,v,sz;
  M() : v(MINF), sz(0) {}
  M(int w) : l(w),r(w),sum(w),v(w), sz(1) {}
  friend M operator*(const M& lhs, const M& rhs) {
    if (lhs.v == MINF) return rhs;
    if (rhs.v == MINF) return lhs;
    M ret;
    ret.l = max(lhs.l, lhs.sum + rhs.l);
    ret.r = max(rhs.r, lhs.r + rhs.sum);
    ret.v = max({lhs.v, rhs.v, lhs.r + rhs.l});
    ret.sum = lhs.sum + rhs.sum;
    ret.sz = lhs.sz + rhs.sz;
    return ret;
  }
};
struct A {
  int v;
  bool f;
  A() : f(false) {}
  A(int v) : v(v), f(true) {}
  bool operator()() const { return f; }
  A& operator*=(const A& r) {
    if (r.f) *this = r;
    return *this;
  }
  M act(const M& m) const {
    if (!f) return m;
    M ret = m;
    ret.sum = v*m.sz;
    ret.l = ret.r = ret.v = (v >= 0 ? ret.sum : v);
    return ret;
  }
};

int main() {
  int n,q; cin>>n>>q;
  vector<int> W(n);
  for (auto& w:W) cin>>w;
  Hld T(n);
  for (int i = 0; i < n-1; i++) {
    int s,e; cin>>s>>e; s--; e--;
    T.add_edge(s,e);
  }
  T.build();
  vector<int> X(n*2);
  for (int i = 0; i < n; i++)
    X[T.in[i]] = X[n+n-1-T.in[i]] = W[i];
  SegmentTreebase<M,A> RQ(X.begin(), X.end());
  auto range_update = [&](int l, int r, int v) {
    RQ.update(l,r,v);
    RQ.update(n+n-r, n+n-l, v);
  };
  auto query = [&](int l, int r) {
    return RQ.query(l,r);
  };
  auto reverse_query = [&](int l, int r) {
    return RQ.query(n+n-r, n+n-l);
  };
  for (int i = 0; i < q; i++) {
    int t; cin>>t;
    if (t == 1) {
      int a,b,c; cin>>a>>b>>c; a--; b--;
      T.update(a,b,range_update,c);
    } else if (t == 2) {
      int a,b,c; cin>>a>>b>>c; a--; b--;
      cout << T.query(a,b,query,reverse_query).v << endl;
    }
  }
}

Test cases

Env Name Status Elapsed Memory
g++ testcase_00 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_01 :heavy_check_mark: AC 5 ms 3 MB
g++ testcase_02 :heavy_check_mark: AC 5 ms 3 MB
g++ testcase_03 :heavy_check_mark: AC 5 ms 3 MB
g++ testcase_04 :heavy_check_mark: AC 6 ms 4 MB
g++ testcase_05 :heavy_check_mark: AC 237 ms 14 MB
g++ testcase_06 :heavy_check_mark: AC 380 ms 47 MB
g++ testcase_07 :heavy_check_mark: AC 464 ms 123 MB
g++ testcase_08 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_09 :heavy_check_mark: AC 79 ms 4 MB
g++ testcase_10 :heavy_check_mark: AC 351 ms 52 MB
g++ testcase_11 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_12 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_13 :heavy_check_mark: AC 7 ms 3 MB
g++ testcase_14 :heavy_check_mark: AC 10 ms 4 MB
g++ testcase_15 :heavy_check_mark: AC 43 ms 4 MB
g++ testcase_16 :heavy_check_mark: AC 230 ms 6 MB
g++ testcase_17 :heavy_check_mark: AC 387 ms 15 MB
g++ testcase_18 :heavy_check_mark: AC 445 ms 28 MB
g++ testcase_19 :heavy_check_mark: AC 703 ms 52 MB
g++ testcase_20 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_21 :heavy_check_mark: AC 6 ms 4 MB
g++ testcase_22 :heavy_check_mark: AC 18 ms 4 MB
g++ testcase_23 :heavy_check_mark: AC 165 ms 5 MB
g++ testcase_24 :heavy_check_mark: AC 505 ms 26 MB
g++ testcase_25 :heavy_check_mark: AC 529 ms 52 MB
g++ testcase_26 :heavy_check_mark: AC 7 ms 3 MB
g++ testcase_27 :heavy_check_mark: AC 366 ms 9 MB
g++ testcase_28 :heavy_check_mark: AC 466 ms 28 MB
g++ testcase_29 :heavy_check_mark: AC 564 ms 52 MB
g++ testcase_30 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_31 :heavy_check_mark: AC 10 ms 3 MB
g++ testcase_32 :heavy_check_mark: AC 59 ms 4 MB
g++ testcase_33 :heavy_check_mark: AC 270 ms 14 MB
g++ testcase_34 :heavy_check_mark: AC 364 ms 28 MB
g++ testcase_35 :heavy_check_mark: AC 451 ms 51 MB
g++ testcase_36 :heavy_check_mark: AC 530 ms 51 MB
g++ testcase_37 :heavy_check_mark: AC 452 ms 52 MB
g++ testcase_38 :heavy_check_mark: AC 444 ms 52 MB
clang++ testcase_00 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_01 :heavy_check_mark: AC 5 ms 3 MB
clang++ testcase_02 :heavy_check_mark: AC 5 ms 3 MB
clang++ testcase_03 :heavy_check_mark: AC 5 ms 3 MB
clang++ testcase_04 :heavy_check_mark: AC 7 ms 3 MB
clang++ testcase_05 :heavy_check_mark: AC 248 ms 10 MB
clang++ testcase_06 :heavy_check_mark: AC 411 ms 31 MB
clang++ testcase_07 :heavy_check_mark: AC 481 ms 64 MB
clang++ testcase_08 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_09 :heavy_check_mark: AC 86 ms 4 MB
clang++ testcase_10 :heavy_check_mark: AC 416 ms 52 MB
clang++ testcase_11 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_12 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_13 :heavy_check_mark: AC 8 ms 3 MB
clang++ testcase_14 :heavy_check_mark: AC 14 ms 3 MB
clang++ testcase_15 :heavy_check_mark: AC 72 ms 4 MB
clang++ testcase_16 :heavy_check_mark: AC 279 ms 6 MB
clang++ testcase_17 :heavy_check_mark: AC 514 ms 15 MB
clang++ testcase_18 :heavy_check_mark: AC 563 ms 27 MB
clang++ testcase_19 :heavy_check_mark: AC 796 ms 52 MB
clang++ testcase_20 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_21 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_22 :heavy_check_mark: AC 20 ms 4 MB
clang++ testcase_23 :heavy_check_mark: AC 293 ms 5 MB
clang++ testcase_24 :heavy_check_mark: AC 570 ms 25 MB
clang++ testcase_25 :heavy_check_mark: AC 743 ms 52 MB
clang++ testcase_26 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_27 :heavy_check_mark: AC 428 ms 9 MB
clang++ testcase_28 :heavy_check_mark: AC 534 ms 27 MB
clang++ testcase_29 :heavy_check_mark: AC 709 ms 52 MB
clang++ testcase_30 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_31 :heavy_check_mark: AC 11 ms 4 MB
clang++ testcase_32 :heavy_check_mark: AC 85 ms 4 MB
clang++ testcase_33 :heavy_check_mark: AC 348 ms 14 MB
clang++ testcase_34 :heavy_check_mark: AC 400 ms 27 MB
clang++ testcase_35 :heavy_check_mark: AC 495 ms 50 MB
clang++ testcase_36 :heavy_check_mark: AC 548 ms 51 MB
clang++ testcase_37 :heavy_check_mark: AC 588 ms 52 MB
clang++ testcase_38 :heavy_check_mark: AC 491 ms 52 MB
Back to top page