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-balanced_tree.test.cpp

Code

#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/problems/2450"
#include "include/mtl/hld.hpp"
#include "include/mtl/segment_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);
  for (int i = 0; i < n; i++) X[T.in[i]] = W[i];
  LazySegmentHld<M,A> RQ(T, X.begin(), X.end());
  auto range_update = [&](int l, int r, int v) {
    RQ.update(l,r,v);
  };
  auto query = [&](int l, int r) {
    return RQ.query(l,r);
  };
  auto r_query = [&](int l, int r) {
    return RQ.reverse_query(l,r);
  };
  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,r_query).v << endl;
    }
  }
}
#line 1 "test/aoj/aoj-do_use_segment_tree-balanced_tree.test.cpp"
#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/problems/2450"
#line 2 "include/mtl/hld.hpp"
#include <cstddef>
#include <vector>

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 2 "include/mtl/monoid.hpp"
#include <utility>
#if __cpp_concepts >= 202002L
#include <concepts>
#endif

template<class T, T (*op)(T, T), T (*e)()>
struct Monoid {
  T x;
  Monoid() : x(e()) {}
  template<class... Args>
  Monoid(Args&&... args) : x(std::forward<Args>(args)...) {}
  Monoid operator*(const Monoid& rhs) const {
    return Monoid(op(x, rhs.x));
  }
  const T& val() const {
    return x;
  }
};

struct VoidMonoid {
  VoidMonoid() {}
  VoidMonoid operator*(const VoidMonoid& rhs) const {
    return VoidMonoid();
  }
};

#if __cpp_concepts >= 202002L
template<class T>
concept IsMonoid = requires (T m) {
  { m * m } -> std::same_as<T>;
};
#endif

template<class T, T (*op)(T, T), T (*e)()>
struct CommutativeMonoid : public Monoid<T, op, e> {
    using Base = Monoid<T, op, e>;
    CommutativeMonoid(T x=e()) : Base(x) {}
    CommutativeMonoid operator+(const CommutativeMonoid& rhs) const {
        return CommutativeMonoid(*this * rhs);
    }
};

#if __cpp_concepts >= 202002L
template<class T>
concept IsCommutativeMonoid = requires (T m) {
  { m + m } -> std::same_as<T>;
};
#endif

template<class S, class F, S (*mapping)(F, S), F (*composition)(F, F), F (*id)()>
struct OperatorMonoid {
    F f;
    OperatorMonoid() : f(id()) {}
    template<class... Args>
    OperatorMonoid(Args&&... args) : f(std::forward<Args>(args)...) {}
    OperatorMonoid& operator*=(const OperatorMonoid& rhs) {
        f = composition(rhs.f, f);
        return *this;
    }
    S act(const S& s) const {
        return mapping(f, s);
    }
};

struct VoidOperatorMonoid {
    VoidOperatorMonoid() {}
    VoidOperatorMonoid& operator*=(const VoidOperatorMonoid& rhs) {
        return *this;
    }
    template<class T>
    T act(const T& s) const {
        return s;
    }
};

#if __cpp_concepts >= 202002L
template<class F, class S>
concept IsOperatorMonoid = requires (F f, S s) {
    { f *= f } -> std::same_as<F&>;
    { f.act(s) } -> std::same_as<S>;
};
#endif
#line 5 "include/mtl/segment_hld.hpp"
#include <cassert>

template<typename Node>
class SegmentHldBase {
 public:
  using monoid_type = typename Node::monoid_type;
 protected:
  int n_;
  std::vector<Node> tree_;
  std::vector<int> target_;
 public:
  explicit SegmentHldBase(const Hld& tree) : n_(tree.n), target_(n_) {
    std::vector<long long> cw(n_+1);
    for (int i = 0; i < n_; i++) {
      int u = tree.rev[i];
      auto w = tree.size[u];
      if (!tree.edge[u].empty() and tree.edge[u][0] != tree.par[u])
        w -= tree.size[tree.edge[u][0]];
      cw[i+1] = cw[i] + w;
    }
    tree_.reserve(n_*2);
    tree_.resize(1);
    tree_[0].l = 0;
    tree_[0].r = n_;
    for (int i = 0; i < (int)tree_.size(); i++) {
      if (tree_[i].size() == 1) {
        target_[tree_[i].l] = i;
        continue;
      }
      auto l = tree_[i].l;
      auto r = tree_[i].r;
      auto mid = upper_bound(cw.begin()+l, cw.begin()+r, (cw[r]+cw[l]+1)/2);
      assert(cw.begin()+l != mid);
      if (*std::prev(mid)-cw[l] > cw[r]-*mid)
        --mid;
      int m = mid-cw.begin();
      if (l < m) {
        tree_[i].lc = tree_.size();
        tree_.emplace_back();
        tree_.back().l = l;
        tree_.back().r = m;
        tree_.back().p = i;
      }
      if (m < r) {
        tree_[i].rc = tree_.size();
        tree_.emplace_back();
        tree_.back().l = m;
        tree_.back().r = r;
        tree_.back().p = i;
      }
    }
  }
  template<typename InputIt>
  explicit SegmentHldBase(const Hld& tree, InputIt begin, InputIt end) : SegmentHldBase(tree) {
    using iterator_value_type = typename std::iterator_traits<InputIt>::value_type;
    static_assert(std::is_convertible<iterator_value_type, monoid_type>::value, 
                  "SegmentHldBaseInputIt must be convertible to Monoid");
    int i = 0;
    for (auto it = begin; it != end; ++it, ++i) {
      tree_[target_[i]].set(monoid_type(*it));
    }
    for (int i = (int)tree_.size()-1; i >= 0; i--) {
      if (tree_[i].size() == 1) continue;
      tree_[i].take(tree_[tree_[i].lc], tree_[tree_[i].rc]);
    }
  }
};

template<typename M>
struct SegmentHldNode {
  using monoid_type = M;
  int l,r,p=-1,lc=-1,rc=-1;
  monoid_type m, rm;
  int size() const {
    return r-l;
  }
  void set(const monoid_type& monoid) {
    m = rm = monoid;
  }
  void take(const SegmentHldNode& lhs, const SegmentHldNode& rhs) {
    m = lhs.m * rhs.m;
    rm = rhs.rm * lhs.rm;
  }
};
template<
#if __cpp_concepts >= 202002L
  IsMonoid
#else
  class
#endif
    M>
class SegmentHld : private SegmentHldBase<SegmentHldNode<M>> {
 public:
  using monoid_type = M; 
 private:
  using Node = SegmentHldNode<M>;
  using Base = SegmentHldBase<Node>;
  using Base::n_;
  using Base::tree_;
  using Base::target_;
 public:
  explicit SegmentHld(const Hld& tree) : Base(tree) {}
  template<typename InputIt>
  explicit SegmentHld(const Hld& tree, InputIt begin, InputIt end) : Base(tree, begin, end) {}
  const monoid_type& get(int index) const {
    return tree_[target_[index]].m;
  }
  const monoid_type& get_reversed(int index) const {
    return tree_[target_[index]].rm;
  }
  template<class... Args>
  void set(int index, Args&&... args) {
    int i = target_[index];
    tree_[i].set(M(std::forward<Args>(args)...));
    i = tree_[i].p;
    while (i != -1) {
      auto lc = tree_[i].lc, rc = tree_[i].rc;
      tree_[i].take(tree_[lc], tree_[rc]);
      i = tree_[i].p;
    }
  }
  M query(int l, int r) const {
    return _query<0>(l,r,0);
  }
  M reverse_query(int l, int r) const {
    return _query<1>(l,r,0);
  }
 private:
  template<bool Reverse>
  M _query(int l, int r, int u) const {
    if (u == -1)
      return M();
    auto _l = tree_[u].l, _r = tree_[u].r;
    if (_r <= l or r <= _l)
      return M();
    if (l <= _l and _r <= r) {
      if constexpr (!Reverse)
        return tree_[u].m;
      else
        return tree_[u].rm;
    }
    auto lc = tree_[u].lc, rc = tree_[u].rc;
    if constexpr (!Reverse)
      return _query<0>(l, r, lc) * _query<0>(l, r, rc);
    else
      return _query<1>(l, r, rc) * _query<1>(l, r, lc);
  }
};


template<typename M, typename A>
struct LazySegmentHldNode : SegmentHldNode<M> {
  using operator_monoid_type = A;
  A a;
};
template<typename M, typename A>
#if __cpp_concepts >= 202002L
requires IsMonoid<M> && IsOperatorMonoid<A, M>
#endif
class LazySegmentHld : private SegmentHldBase<LazySegmentHldNode<M,A>> {
 public:
  using monoid_type = M;
  using operator_monoid_type = A;
 private:
  using Node = LazySegmentHldNode<M,A>;
  using Base = SegmentHldBase<Node>;
  using Base::n_;
  using Base::tree_;
  using Base::target_;
 public:
  explicit LazySegmentHld(const Hld& tree) : Base(tree) {}
  template<typename InputIt>
  explicit LazySegmentHld(const Hld& tree, InputIt begin, InputIt end) : Base(tree, begin, end) {}
 private:
  inline void _propagate(int u) {
    auto& n = tree_[u];
    auto& a = n.a;
    if (!a()) return;
    n.m = a.act(n.m);
    n.rm = a.act(n.rm);
    if (n.size() > 1) {
      tree_[n.lc].a *= a;
      tree_[n.rc].a *= a;
    }
    n.a = A();
  }
 public:
  template<typename T>
  void set(int index, T&& v) {
    std::vector<int> ids;
    int u = target_[index];
    ids.push_back(u);
    u = tree_[u].p;
    while (u != -1) {
      ids.push_back(u);
      u = tree_[u].p;
    }
    for (int i = (int)ids.size()-1; i >= 0; i--) {
      _propagate(ids[i]);
    }
    tree_[ids[0]].set(monoid_type(std::forward<T>(v)));
    for (int i = 1; i < ids.size(); i++) {
      u = ids[i];
      auto lc = tree_[u].lc, rc = tree_[u].rc;
      auto ac = lc ^ rc ^ ids[i-1];
      _propagate(ac);
      tree_[u].take(tree_[lc], tree_[rc]);
    }
  }
  M query(int l, int r) {
    return _query<0>(l,r,0);
  }
  M reverse_query(int l, int r) {
    return _query<1>(l,r,0);
  }
 private:
  template<bool Reverse>
  M _query(int l, int r, int u) {
    if (u == -1)
      return M();
    auto _l = tree_[u].l, _r = tree_[u].r;
    if (_r <= l or r <= _l)
      return M();
    _propagate(u);
    if (l <= _l and _r <= r) {
      if constexpr (!Reverse)
        return tree_[u].m;
      else
        return tree_[u].rm;
    } else {
      if constexpr (!Reverse)
        return _query<0>(l, r, tree_[u].lc) * _query<0>(l, r, tree_[u].rc);
      else
        return _query<1>(l, r, tree_[u].rc) * _query<1>(l, r, tree_[u].lc);
    }
  }
 public:
  template<typename T>
  void update(int l, int r, const T& v) {
    _update(l, r, v, 0);
  }
 private:
  template<typename T>
  void _update(int l, int r, const T& v, int u) {
    if (u == -1)
      return;
    auto _l = tree_[u].l, _r = tree_[u].r;
    if (_r <= l or r <= _l) {
      _propagate(u);
    } else if (l <= _l and _r <= r) {
      tree_[u].a *= v;
      _propagate(u);
    } else {
      _propagate(u);
      if (tree_[u].size() > 1) {
        auto lc = tree_[u].lc, rc = tree_[u].rc;
        _update(l, r, v, lc);
        _update(l, r, v, rc);
        tree_[u].take(tree_[lc], tree_[rc]);
      }
    }
  }
};
#line 4 "test/aoj/aoj-do_use_segment_tree-balanced_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);
  for (int i = 0; i < n; i++) X[T.in[i]] = W[i];
  LazySegmentHld<M,A> RQ(T, X.begin(), X.end());
  auto range_update = [&](int l, int r, int v) {
    RQ.update(l,r,v);
  };
  auto query = [&](int l, int r) {
    return RQ.query(l,r);
  };
  auto r_query = [&](int l, int r) {
    return RQ.reverse_query(l,r);
  };
  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,r_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 226 ms 13 MB
g++ testcase_06 :heavy_check_mark: AC 377 ms 47 MB
g++ testcase_07 :heavy_check_mark: AC 650 ms 123 MB
g++ testcase_08 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_09 :heavy_check_mark: AC 52 ms 4 MB
g++ testcase_10 :heavy_check_mark: AC 392 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 8 ms 3 MB
g++ testcase_14 :heavy_check_mark: AC 13 ms 4 MB
g++ testcase_15 :heavy_check_mark: AC 57 ms 4 MB
g++ testcase_16 :heavy_check_mark: AC 248 ms 6 MB
g++ testcase_17 :heavy_check_mark: AC 609 ms 15 MB
g++ testcase_18 :heavy_check_mark: AC 534 ms 27 MB
g++ testcase_19 :heavy_check_mark: AC 679 ms 51 MB
g++ testcase_20 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_21 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_22 :heavy_check_mark: AC 18 ms 4 MB
g++ testcase_23 :heavy_check_mark: AC 182 ms 5 MB
g++ testcase_24 :heavy_check_mark: AC 540 ms 22 MB
g++ testcase_25 :heavy_check_mark: AC 596 ms 51 MB
g++ testcase_26 :heavy_check_mark: AC 7 ms 3 MB
g++ testcase_27 :heavy_check_mark: AC 502 ms 8 MB
g++ testcase_28 :heavy_check_mark: AC 529 ms 27 MB
g++ testcase_29 :heavy_check_mark: AC 662 ms 51 MB
g++ testcase_30 :heavy_check_mark: AC 6 ms 3 MB
g++ testcase_31 :heavy_check_mark: AC 10 ms 4 MB
g++ testcase_32 :heavy_check_mark: AC 60 ms 4 MB
g++ testcase_33 :heavy_check_mark: AC 332 ms 11 MB
g++ testcase_34 :heavy_check_mark: AC 338 ms 27 MB
g++ testcase_35 :heavy_check_mark: AC 593 ms 49 MB
g++ testcase_36 :heavy_check_mark: AC 460 ms 50 MB
g++ testcase_37 :heavy_check_mark: AC 445 ms 51 MB
g++ testcase_38 :heavy_check_mark: AC 535 ms 51 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 6 ms 3 MB
clang++ testcase_05 :heavy_check_mark: AC 222 ms 9 MB
clang++ testcase_06 :heavy_check_mark: AC 357 ms 31 MB
clang++ testcase_07 :heavy_check_mark: AC 425 ms 63 MB
clang++ testcase_08 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_09 :heavy_check_mark: AC 50 ms 4 MB
clang++ testcase_10 :heavy_check_mark: AC 406 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 6 ms 3 MB
clang++ testcase_14 :heavy_check_mark: AC 10 ms 3 MB
clang++ testcase_15 :heavy_check_mark: AC 44 ms 4 MB
clang++ testcase_16 :heavy_check_mark: AC 296 ms 6 MB
clang++ testcase_17 :heavy_check_mark: AC 413 ms 15 MB
clang++ testcase_18 :heavy_check_mark: AC 534 ms 27 MB
clang++ testcase_19 :heavy_check_mark: AC 658 ms 51 MB
clang++ testcase_20 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_21 :heavy_check_mark: AC 7 ms 3 MB
clang++ testcase_22 :heavy_check_mark: AC 26 ms 4 MB
clang++ testcase_23 :heavy_check_mark: AC 172 ms 5 MB
clang++ testcase_24 :heavy_check_mark: AC 577 ms 22 MB
clang++ testcase_25 :heavy_check_mark: AC 620 ms 51 MB
clang++ testcase_26 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_27 :heavy_check_mark: AC 393 ms 8 MB
clang++ testcase_28 :heavy_check_mark: AC 498 ms 27 MB
clang++ testcase_29 :heavy_check_mark: AC 729 ms 51 MB
clang++ testcase_30 :heavy_check_mark: AC 6 ms 3 MB
clang++ testcase_31 :heavy_check_mark: AC 13 ms 3 MB
clang++ testcase_32 :heavy_check_mark: AC 56 ms 4 MB
clang++ testcase_33 :heavy_check_mark: AC 293 ms 11 MB
clang++ testcase_34 :heavy_check_mark: AC 334 ms 27 MB
clang++ testcase_35 :heavy_check_mark: AC 576 ms 48 MB
clang++ testcase_36 :heavy_check_mark: AC 434 ms 50 MB
clang++ testcase_37 :heavy_check_mark: AC 452 ms 51 MB
clang++ testcase_38 :heavy_check_mark: AC 482 ms 51 MB
Back to top page