#ifdef NACHIA // #define _GLIBCXX_DEBUG #else #define NDEBUG #endif #include #include #include #include #include #include #include #include #include using i64 = long long; using u64 = unsigned long long; #define rep(i,n) for(i64 i=0; i<(i64)(n); i++) #define repr(i,n) for(i64 i=(i64)(n)-1; i>=0; i--) const i64 INF = 1001001001001001001; const char* yn(bool x){ return x ? "Yes" : "No"; } template void chmin(A& l, const A& r){ if(r < l) l = r; } template void chmax(A& l, const A& r){ if(l < r) l = r; } template using nega_queue = std::priority_queue,std::greater>; using Modint = atcoder::static_modint<998244353>; #include #include template struct vec; template struct seq_view{ using Ref = typename std::iterator_traits::reference; using Elem = typename std::iterator_traits::value_type; Iter a, b; Iter begin() const { return a; } Iter end() const { return b; } int size() const { return (int)(b-a); } seq_view(Iter first, Iter last) : a(first), b(last) {} seq_view sort() const { std::sort(a, b); return *this; } Ref& operator[](int x){ return *(a+x); } template, class ret = vec> ret sorti(F f = F()) const { ret x(size()); for(int i=0; i> ret col() const { return ret(begin(), end()); } template, class ret = vec>> ret rle(F eq = F()) const { auto x = ret(); for(auto& a : (*this)){ if(x.size() == 0 || !eq(x[x.size()-1].first, a)) x.emp(a, 1); else x[x.size()-1].second++; } return x; } template seq_view sort(F f) const { std::sort(a, b, f); return *this; } Iter uni() const { return std::unique(a, b); } Iter lb(const Elem& x) const { return std::lower_bound(a, b, x); } Iter ub(const Elem& x) const { return std::upper_bound(a, b, x); } int lbi(const Elem& x) const { return lb(x) - a; } int ubi(const Elem& x) const { return ub(x) - a; } seq_view bound(const Elem& l, const Elem& r) const { return { lb(l), lb(r) }; } template Iter lb(const Elem& x, F f) const { return std::lower_bound(a, b, x, f); } template Iter ub(const Elem& x, F f) const { return std::upper_bound(a, b, x, f); } template Iter when_true_to_false(F f) const { if(a == b) return a; return std::lower_bound(a, b, *a, [&](const Elem& x, const Elem&){ return f(x); }); } seq_view same(Elem x) const { return { lb(x), ub(x) }; } template auto map(F f) const { vec r; for(auto& x : *this) r.emp(f(x)); return r; } Iter max() const { return std::max_element(a, b); } Iter min() const { return std::min_element(a, b); } template> Iter min(F f) const { return std::min_element(a, b, f); } seq_view rev() const { std::reverse(a, b); return *this; } }; template struct vec { using Base = typename std::vector; using Iter = typename Base::iterator; using CIter = typename Base::const_iterator; using View = seq_view; using CView = seq_view; vec(){} explicit vec(int n, const Elem& value = Elem()) : a(0 vec(I2 first, I2 last) : a(first, last) {} vec(std::initializer_list il) : a(std::move(il)) {} vec(Base b) : a(std::move(b)) {} operator Base() const { return a; } Iter begin(){ return a.begin(); } CIter begin() const { return a.begin(); } Iter end(){ return a.end(); } CIter end() const { return a.end(); } int size() const { return a.size(); } bool empty() const { return a.empty(); } Elem& back(){ return a.back(); } const Elem& back() const { return a.back(); } vec sortunied(){ vec x = *this; x().sort(); x.a.erase(x().uni(), x.end()); return x; } Iter operator()(int x){ return a.begin() + x; } CIter operator()(int x) const { return a.begin() + x; } View operator()(int l, int r){ return { (*this)(l), (*this)(r) }; } CView operator()(int l, int r) const { return { (*this)(l), (*this)(r) }; } View operator()(){ return (*this)(0,size()); } CView operator()() const { return (*this)(0,size()); } Elem& operator[](int x){ return a[x]; } const Elem& operator[](int x) const { return a[x]; } Base& operator*(){ return a; } const Base& operator*() const { return a; } vec& push(Elem args){ a.push_back(std::move(args)); return *this; } template vec& emp(Args &&... args){ a.emplace_back(std::forward(args) ...); return *this; } template vec& app(Range& x){ for(auto& v : a) emp(v); } Elem pop(){ Elem x = std::move(a.back()); a.pop_back(); return x; } bool operator==(const vec& r) const { return a == r.a; } bool operator!=(const vec& r) const { return a != r.a; } bool operator<(const vec& r) const { return a < r.a; } bool operator<=(const vec& r) const { return a <= r.a; } bool operator>(const vec& r) const { return a > r.a; } bool operator>=(const vec& r) const { return a >= r.a; } vec> pile(int n) const { return vec>(n, *this); } template vec& filter(F f){ int p = 0; for(int q=0; q IStr& operator>>(IStr& is, vec>& v){ for(auto& x:v){ is >> x.first >> x.second; } return is; } template IStr& operator>>(IStr& is, vec& v){ for(auto& x:v){ is >> x; } return is; } template OStr& operator<<(OStr& os, const vec& v){ for(int i=0; i OStr& operator<<(OStr& os, const vec>& v){ for(int i=0; i class CsrArray{ public: struct ListRange{ using iterator = typename std::vector::iterator; iterator begi, endi; iterator begin() const { return begi; } iterator end() const { return endi; } int size() const { return (int)std::distance(begi, endi); } Elem& operator[](int i) const { return begi[i]; } }; struct ConstListRange{ using iterator = typename std::vector::const_iterator; iterator begi, endi; iterator begin() const { return begi; } iterator end() const { return endi; } int size() const { return (int)std::distance(begi, endi); } const Elem& operator[](int i) const { return begi[i]; } }; private: int m_n; std::vector m_list; std::vector m_pos; public: CsrArray() : m_n(0), m_list(), m_pos() {} static CsrArray Construct(int n, std::vector> items){ CsrArray res; res.m_n = n; std::vector buf(n+1, 0); for(auto& [u,v] : items){ ++buf[u]; } for(int i=1; i<=n; i++) buf[i] += buf[i-1]; res.m_list.resize(buf[n]); for(int i=(int)items.size()-1; i>=0; i--){ res.m_list[--buf[items[i].first]] = std::move(items[i].second); } res.m_pos = std::move(buf); return res; } static CsrArray FromRaw(std::vector list, std::vector pos){ CsrArray res; res.m_n = pos.size() - 1; res.m_list = std::move(list); res.m_pos = std::move(pos); return res; } ListRange operator[](int u) { return ListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; } ConstListRange operator[](int u) const { return ConstListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; } int size() const { return m_n; } int fullSize() const { return (int)m_list.size(); } }; } // namespace nachia #include namespace nachia{ struct Graph { public: struct Edge{ int from, to; void reverse(){ std::swap(from, to); } int xorval() const { return from ^ to; } }; Graph(int n = 0, bool undirected = false, int m = 0) : m_n(n), m_e(m), m_isUndir(undirected) {} Graph(int n, const std::vector>& edges, bool undirected = false) : m_n(n), m_isUndir(undirected){ m_e.resize(edges.size()); for(std::size_t i=0; i static Graph Input(Cin& cin, int n, bool undirected, int m, bool offset = 0){ Graph res(n, undirected, m); for(int i=0; i> u >> v; res[i].from = u - offset; res[i].to = v - offset; } return res; } int numVertices() const noexcept { return m_n; } int numEdges() const noexcept { return int(m_e.size()); } int addNode() noexcept { return m_n++; } int addEdge(int from, int to){ m_e.push_back({ from, to }); return numEdges() - 1; } Edge& operator[](int ei) noexcept { return m_e[ei]; } const Edge& operator[](int ei) const noexcept { return m_e[ei]; } Edge& at(int ei) { return m_e.at(ei); } const Edge& at(int ei) const { return m_e.at(ei); } auto begin(){ return m_e.begin(); } auto end(){ return m_e.end(); } auto begin() const { return m_e.begin(); } auto end() const { return m_e.end(); } bool isUndirected() const noexcept { return m_isUndir; } void reverseEdges() noexcept { for(auto& e : m_e) e.reverse(); } void contract(int newV, const std::vector& mapping){ assert(numVertices() == int(mapping.size())); for(int i=0; i induce(int num, const std::vector& mapping) const { int n = numVertices(); assert(n == int(mapping.size())); for(int i=0; i indexV(n), newV(num); for(int i=0; i= 0) indexV[i] = newV[mapping[i]]++; std::vector res; res.reserve(num); for(int i=0; i= 0) res[mapping[e.to]].addEdge(indexV[e.from], indexV[e.to]); return res; } CsrArray getEdgeIndexArray(bool undirected) const { std::vector> src; src.reserve(numEdges() * (undirected ? 2 : 1)); for(int i=0; i::Construct(numVertices(), src); } CsrArray getEdgeIndexArray() const { return getEdgeIndexArray(isUndirected()); } CsrArray getAdjacencyArray(bool undirected) const { std::vector> src; src.reserve(numEdges() * (undirected ? 2 : 1)); for(auto e : m_e){ src.emplace_back(e.from, e.to); if(undirected) src.emplace_back(e.to, e.from); } return CsrArray::Construct(numVertices(), src); } CsrArray getAdjacencyArray() const { return getAdjacencyArray(isUndirected()); } private: int m_n; std::vector m_e; bool m_isUndir; }; } // namespace nachia namespace nachia{ struct HeavyLightDecomposition{ private: int N; std::vector P; std::vector PP; std::vector PD; std::vector D; std::vector I; std::vector rangeL; std::vector rangeR; public: HeavyLightDecomposition(const CsrArray& E = CsrArray::Construct(1, {}), int root = 0){ N = E.size(); P.assign(N, -1); I.assign(N, 0); I[0] = root; int iI = 1; for(int i=0; i Z(N, 1); std::vector nx(N, -1); PP.resize(N); for(int i=0; i=1; i--){ int p = I[i]; Z[P[p]] += Z[p]; if(nx[P[p]] == -1) nx[P[p]] = p; if(Z[nx[P[p]]] < Z[p]) nx[P[p]] = p; } for(int p : I) if(nx[p] != -1) PP[nx[p]] = p; PD.assign(N,N); PD[root] = 0; D.assign(N,0); for(int p : I) if(p != root){ PP[p] = PP[PP[p]]; PD[p] = std::min(PD[PP[p]], PD[P[p]]+1); D[p] = D[P[p]]+1; } rangeL.assign(N,0); rangeR.assign(N,0); for(int p : I){ rangeR[p] = rangeL[p] + Z[p]; int ir = rangeR[p]; for(int e : E[p]) if(P[p] != e) if(e != nx[p]){ rangeL[e] = (ir -= Z[e]); } if(nx[p] != -1){ rangeL[nx[p]] = rangeL[p] + 1; } } I.resize(N); for(int i=0; i PD[v]) u = P[PP[u]]; while(PP[u] != PP[v]){ u = P[PP[u]]; v = P[PP[v]]; } return (D[u] > D[v]) ? v : u; } int dist(int u, int v) const { return depth(u) + depth(v) - depth(lca(u,v)) * 2; } struct Range{ int l; int r; int size() const { return r-l; } bool includes(int x) const { return l <= x && x < r; } }; std::vector path(int r, int c, bool include_root = true, bool reverse_path = false) const { if(PD[c] < PD[r]) return {}; std::vector res(PD[c]-PD[r]+1); for(int i=0; i<(int)res.size()-1; i++){ res[i] = { rangeL[PP[c]], rangeL[c]+1 }; c = P[PP[c]]; } if(PP[r] != PP[c] || D[r] > D[c]) return {}; res.back() = { rangeL[r]+(include_root?0:1), rangeL[c]+1 }; if(res.back().l == res.back().r) res.pop_back(); if(!reverse_path) std::reverse(res.begin(),res.end()); else for(auto& a : res) a = { N - a.r, N - a.l }; return res; } Range subtree(int p) const { return { rangeL[p], rangeR[p] }; } int median(int x, int y, int z) const { return lca(x,y) ^ lca(y,z) ^ lca(x,z); } int la(int from, int to, int d) const { if(d < 0) return -1; int g = lca(from,to); int dist0 = D[from] - D[g] * 2 + D[to]; if(dist0 < d) return -1; int p = from; if(D[from] - D[g] < d){ p = to; d = dist0 - d; } while(D[p] - D[PP[p]] < d){ d -= D[p] - D[PP[p]] + 1; p = P[PP[p]]; } return I[rangeL[p] - d]; } struct ChildrenIterRange { struct Iter { const HeavyLightDecomposition& hld; int s; int operator*() const { return hld.toVtx(s); } Iter& operator++(){ s += hld.subtree(hld.I[s]).size(); return *this; } Iter operator++(int) const { auto a = *this; return ++a; } bool operator==(Iter& r) const { return s == r.s; } bool operator!=(Iter& r) const { return s != r.s; } }; const HeavyLightDecomposition& hld; int v; Iter begin() const { return { hld, hld.rangeL[v] + 1 }; } Iter end() const { return { hld, hld.rangeR[v] }; } }; ChildrenIterRange children(int v) const { return ChildrenIterRange{ *this, v }; } }; } // namespace nachia #include namespace nachia{ template< class S, S op(S l, S r) > struct Segtree { private: int N; std::vector A; int xN; void mergev(int i){ if(i < N) A[i] = op(A[i*2], A[i*2+1]); } template int minLeft2(int r, E cmp, int a = 0, int b = 0, int i = -1) const { static S x; if(i == -1){ a=0; b=N; i=1; x=A[0]; } if(r <= a) return a; if(b <= r){ S nx = op(A[i], x); if(cmp(nx)){ x = nx; return a; } } if(b - a == 1) return b; int q = minLeft2(r, cmp, (a+b)/2, b, i*2+1); if(q > (a+b)/2) return q; return minLeft2(r, cmp, a, (a+b)/2, i*2); } template int maxRight2(int l, E cmp, int a = 0, int b = 0, int i = -1) const { static S x; if(i == -1){ a=0; b=N; i=1; x=A[0]; } if(b <= l) return b; if(l <= a){ S nx = op(x, A[i]); if(cmp(nx)){ x = nx; return b; } } if(b - a == 1) return a; int q = maxRight2(l, cmp, a, (a+b)/2, i*2); if(q < (a+b)/2) return q; return maxRight2(l, cmp, (a+b)/2, b, i*2+1); } public: Segtree() : N(0) {} Segtree(int n, S e) : xN(n) { N = 1; while (N < n) N *= 2; A.assign(N * 2, e); } Segtree(const std::vector& a, S e) : Segtree(a.size(), e){ for(int i=0; i<(int)a.size(); i++) A[i + N] = a[i]; for(int i=N-1; i>=1; i--) mergev(i); } void set(int p, S x){ p += N; A[p] = x; for(int d=1; (1<>d); } S get(int p) const { return A[N+p]; } S prod(int l, int r) const { l += N; r += N; S ql = A[0], qr = A[0]; while(l int minLeft(int r, E cmp) const { return minLeft2(r, cmp); } // bool cmp(S) template int maxRight(int l, E cmp) const { int x = maxRight2(l, cmp); return x > xN ? xN : x; } }; } // namespace nachia namespace nachia { template> struct PointSetRangeMin{ private: static T minop(T l, T r){ return std::min(l, r, Cmp()); } using Base = Segtree; Base base; Cmp cmpx; public: PointSetRangeMin() {} PointSetRangeMin(int len, T INF) : base(len, INF){} PointSetRangeMin(const std::vector& init, T INF) : base(init, INF){} T min(int l, int r){ return base.prod(l, r); } T min(){ return base.allProd(); } void set(int pos, T val){ base.set(pos, val); } T get(int pos){ return base.get(pos); } void chmin(int pos, T val){ base.set(pos, minop(get(pos), val)); } int lBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return cmpx(val, x); }); } int uBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return !cmpx(x, val); }); } int lBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return cmpx(val, x); }); } int uBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return !cmpx(x, val); }); } template int minLeft(int r, E cmp){ return base.minLeft(r, cmp); } template int maxRight(int l, E cmp){ return base.maxRight(l, cmp); } }; } // namespace nachia void testcase(){ int N; cin >> N; vec A(N); cin >> A; auto tree = nachia::Graph::Input(cin, N, true, N-1, 1); auto hld = nachia::HeavyLightDecomposition(tree); map> Q; auto seg0 = nachia::PointSetRangeMin>(N, -1001001001); auto seg1 = nachia::PointSetRangeMin>(N, -1001001001); rep(i,N) Q[-A[i]].push(i); vec ans(N); for(auto &[aaaa,q] : Q){ for(auto v : q){ int d = hld.depth(v); for(auto [l,r] : hld.path(0,v)) if(l < r){ seg1.chmin(r-1, d); seg0.chmin(r-1, d - hld.depth(hld.toVtx(r-1)) * 2); } } for(auto v : q){ int t = 0; int d = hld.depth(v); for(auto [l,r] : hld.path(0,v)) if(l < r){ int w = hld.toVtx(r-1); if(hld.heavyChildOf(w) >= 0){ int x = hld.heavyChildOf(w); auto [sl,sr] = hld.subtree(x); chmax(t, seg1.min(sl, sr) + d - hld.depth(w) * 2); } chmax(t, seg0.min(l, r-1) + d); } ans[v] = t; } } cout << ans << '\n'; } int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); #ifdef NACHIA int T; cin >> T; for(int t=0; t