Problem p02698 (C++) — buggy submission, verdict: Runtime Error

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstddef>
#include <deque>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <variant>
#include <vector>
#define endl codeforces
#define ALL(v) std::begin(v), std::end(v)
#define ALLR(v) std::rbegin(v), std::rend(v)
using ll = std::int64_t;
using ull = std::uint64_t;
using pii = std::pair<int, int>;
using tii = std::tuple<int, int, int>;
using pll = std::pair<ll, ll>;
using tll = std::tuple<ll, ll, ll>;
template <typename T> using vec = std::vector<T>;
template <typename T> using vvec = vec<vec<T>>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
  return std::min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
  return std::max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
  t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
  t = var_max(t, tail...);
}
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, std::size_t s, Tail... tail) {
  auto v = std::move(make_v(init, tail...));
  return vec<decltype(v)>(s, v);
}
template <typename T, std::size_t Head, std::size_t... Tail>
struct multi_dem_array {
  using type = std::array<typename multi_dem_array<T, Tail...>::type, Head>;
};
template <typename T, std::size_t Head> struct multi_dem_array<T, Head> {
  using type = std::array<T, Head>;
};
template <typename T, std::size_t... Args>
using mdarray = typename multi_dem_array<T, Args...>::type;
namespace init__ {
struct InitIO {
  InitIO() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(30);
  }
} init_io;
} // namespace init__

namespace graph {

using Node = ll;
using Weight = ll;
using Edge = std::pair<Node, Weight>;

template <bool Directed> struct Graph : public vvec<Edge> {
  using vvec<Edge>::vvec;

  void add_edge(Node f, Node t, Weight w = 1) {
    (*this)[f].emplace_back(t, w);
    if (!Directed)
      (*this)[t].emplace_back(f, w);
  }

  Graph<Directed> build_inv() const {
    Graph<Directed> ret(this->size());
    for (Node i = 0; i < this->size(); i++) {
      for (const Edge &e : (*this)[i]) {
        Node j;
        Weight w;
        std::tie(j, w) = e;
        if (!Directed && j < i)
          continue;
        ret.add_edge(j, i, w);
      }
    }

    return ret;
  }
};

template <typename Iterator> class dst_iterator {
  Iterator ite;

public:
  dst_iterator(Iterator ite) : ite(ite) {}

  bool operator==(const dst_iterator<Iterator> &oth) const {
    return ite == oth.ite;
  }

  bool operator!=(const dst_iterator<Iterator> &oth) const {
    return !(*this == oth);
  }

  bool operator<(const dst_iterator<Iterator> &oth) const {
    return ite < oth.ite;
  }

  bool operator>(const dst_iterator<Iterator> &oth) const {
    return ite > oth.ite;
  }

  bool operator<=(const dst_iterator<Iterator> &oth) const {
    return ite <= oth.ite;
  }

  bool operator>=(const dst_iterator<Iterator> &oth) const {
    return ite >= oth.ite;
  }

  const Node &operator*() { return ite->first; }

  const Node &operator*() const { return ite->first; }

  dst_iterator operator++() {
    ++ite;
    return ite;
  }
};

class dst_iteration {
  using ite_type = vec<Edge>::const_iterator;
  const vec<Edge> &edges;

public:
  dst_iteration(const vec<Edge> &edges) : edges(edges) {}

  auto begin() const { return dst_iterator<ite_type>(edges.cbegin()); }

  auto end() const { return dst_iterator<ite_type>(edges.cend()); }
};

dst_iteration dst(const vec<Edge> &edges) { return dst_iteration(edges); }

} // namespace graph

const ll inf = 5e15;

void dfs(ll cur, ll pre, const graph::Graph<false> &tree, vec<ll> &col,
         vec<ll> &ans, const vec<ll> &av) {
  ll a = av[cur];
  auto ite = std::lower_bound(ALL(col), a);
  ll idx = -1, pval;
  if (*ite != a) {
    idx = std::distance(col.begin(), ite);
    pval = *ite;
    col[idx] = a;
  }
  ans[cur] = std::distance(col.begin(), std::lower_bound(ALL(col), inf));
  for (ll nxt : graph::dst(tree[cur]))
    if (nxt != pre)
      dfs(nxt, cur, tree, col, ans, av);
  if (idx != -1)
    col[idx] = pval;
}

int main() {
  ll n;
  std::cin >> n;
  vec<ll> av(n);
  for (ll &e : av)
    std::cin >> e;
  graph::Graph<false> tree(n);
  for (ll i = 1; i < n; i++) {
    ll u, v;
    std::cin >> u >> v;
    tree.add_edge(u - 1, v - 1);
  }
  vec<ll> col(n + 10, inf);
  vec<ll> ans(n);
  dfs(0, -1, tree, col, ans, av);
  for (ll e : ans)
    std::cout << e << "\\n";
  return 0;
}


Error: 0

Fixed submission:

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstddef>
#include <deque>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <variant>
#include <vector>
#define endl codeforces
#define ALL(v) std::begin(v), std::end(v)
#define ALLR(v) std::rbegin(v), std::rend(v)
using ll = std::int64_t;
using ull = std::uint64_t;
using pii = std::pair<int, int>;
using tii = std::tuple<int, int, int>;
using pll = std::pair<ll, ll>;
using tll = std::tuple<ll, ll, ll>;
template <typename T> using vec = std::vector<T>;
template <typename T> using vvec = vec<vec<T>>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
  return std::min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
  return std::max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
  t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
  t = var_max(t, tail...);
}
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, std::size_t s, Tail... tail) {
  auto v = std::move(make_v(init, tail...));
  return vec<decltype(v)>(s, v);
}
template <typename T, std::size_t Head, std::size_t... Tail>
struct multi_dem_array {
  using type = std::array<typename multi_dem_array<T, Tail...>::type, Head>;
};
template <typename T, std::size_t Head> struct multi_dem_array<T, Head> {
  using type = std::array<T, Head>;
};
template <typename T, std::size_t... Args>
using mdarray = typename multi_dem_array<T, Args...>::type;
namespace init__ {
struct InitIO {
  InitIO() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(30);
  }
} init_io;
} // namespace init__

namespace graph {

using Node = ll;
using Weight = ll;
using Edge = std::pair<Node, Weight>;

template <bool Directed> struct Graph : public vvec<Edge> {
  using vvec<Edge>::vvec;

  void add_edge(Node f, Node t, Weight w = 1) {
    (*this)[f].emplace_back(t, w);
    if (!Directed)
      (*this)[t].emplace_back(f, w);
  }

  Graph<Directed> build_inv() const {
    Graph<Directed> ret(this->size());
    for (Node i = 0; i < this->size(); i++) {
      for (const Edge &e : (*this)[i]) {
        Node j;
        Weight w;
        std::tie(j, w) = e;
        if (!Directed && j < i)
          continue;
        ret.add_edge(j, i, w);
      }
    }

    return ret;
  }
};

template <typename Iterator> class dst_iterator {
  Iterator ite;

public:
  dst_iterator(Iterator ite) : ite(ite) {}

  bool operator==(const dst_iterator<Iterator> &oth) const {
    return ite == oth.ite;
  }

  bool operator!=(const dst_iterator<Iterator> &oth) const {
    return !(*this == oth);
  }

  bool operator<(const dst_iterator<Iterator> &oth) const {
    return ite < oth.ite;
  }

  bool operator>(const dst_iterator<Iterator> &oth) const {
    return ite > oth.ite;
  }

  bool operator<=(const dst_iterator<Iterator> &oth) const {
    return ite <= oth.ite;
  }

  bool operator>=(const dst_iterator<Iterator> &oth) const {
    return ite >= oth.ite;
  }

  const Node &operator*() { return ite->first; }

  const Node &operator*() const { return ite->first; }

  dst_iterator operator++() {
    ++ite;
    return ite;
  }
};

class dst_iteration {
  using ite_type = vec<Edge>::const_iterator;
  const vec<Edge> &edges;

public:
  dst_iteration(const vec<Edge> &edges) : edges(edges) {}

  auto begin() const { return dst_iterator<ite_type>(edges.cbegin()); }

  auto end() const { return dst_iterator<ite_type>(edges.cend()); }
};

dst_iteration dst(const vec<Edge> &edges) { return dst_iteration(edges); }

} // namespace graph

const ll inf = 5e15;

void dfs(ll cur, ll pre, const graph::Graph<false> &tree, vec<ll> &col,
         vec<ll> &ans, const vec<ll> &av) {
  ll a = av[cur];
  auto ite = std::lower_bound(ALL(col), a);
  ll idx = -1, pval;
  if (*ite != a) {
    idx = std::distance(col.begin(), ite);
    pval = *ite;
    col[idx] = a;
  }
  ans[cur] = std::distance(col.begin(), std::lower_bound(ALL(col), inf));
  for (ll nxt : graph::dst(tree[cur]))
    if (nxt != pre)
      dfs(nxt, cur, tree, col, ans, av);
  col[idx] = pval;
}

int main() {
  ll n;
  std::cin >> n;
  vec<ll> av(n);
  for (ll &e : av)
    std::cin >> e;
  graph::Graph<false> tree(n);
  for (ll i = 1; i < n; i++) {
    ll u, v;
    std::cin >> u >> v;
    tree.add_edge(u - 1, v - 1);
  }
  vec<ll> col(n + 10, inf);
  vec<ll> ans(n);
  dfs(0, -1, tree, col, ans, av);
  for (ll e : ans)
    std::cout << e << "\\n";
  return 0;
}