#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 #include namespace nachia{ template 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 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 DsuFast{ private: std::vector w; public: DsuFast(int n = 0) : w(n, -1) {} int leader(int u){ if(w[u] < 0) return u; return w[u] = leader(w[u]); } int operator[](int u){ return leader(u); } int merge(int u, int v){ u = leader(u); v = leader(v); if(u == v) return u; if(-w[u] < -w[v]) std::swap(u, v); w[u] += w[v]; w[v] = u; return u; } int size(int u){ return -w[leader(u)]; } bool same(int u, int v){ return leader(u) == leader(v); } }; } // namespace nachia namespace nachia{ std::vector MinimumSpanningForestKnownPriority( const nachia::Graph& graph, const std::vector& edgePriorityOrdered ){ int m = graph.numEdges(); auto dsu = nachia::DsuFast(graph.numVertices()); std::vector ans; for(int i=0; i std::vector MinimumSpanningForest( const nachia::Graph& graph, const std::vector& weight ){ int m = graph.numEdges(); std::vector P(m); for(int i=0; i 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; } } 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 namespace nachia{ int Popcount(unsigned long long c) noexcept { #ifdef __GNUC__ return __builtin_popcountll(c); #else c = (c & (~0ull/3)) + ((c >> 1) & (~0ull/3)); c = (c & (~0ull/5)) + ((c >> 2) & (~0ull/5)); c = (c & (~0ull/17)) + ((c >> 4) & (~0ull/17)); c = (c * (~0ull/257)) >> 56; return c; #endif } // please ensure x != 0 int MsbIndex(unsigned long long x) noexcept { #ifdef __GNUC__ return 63 - __builtin_clzll(x); #else using u64 = unsigned long long; int q = (x >> 32) ? 32 : 0; auto m = x >> q; constexpr u64 hi = 0x8888'8888; constexpr u64 mi = 0x1111'1111; m = (((m | ~(hi - (m & ~hi))) & hi) * mi) >> 35; m = (((m | ~(hi - (x & ~hi))) & hi) * mi) >> 31; q += (m & 0xf) << 2; q += 0x3333'3333'2222'1100 >> (((x >> q) & 0xf) << 2) & 0xf; return q; #endif } // please ensure x != 0 int LsbIndex(unsigned long long x) noexcept { #ifdef __GNUC__ return __builtin_ctzll(x); #else return MsbIndex(x & -x); #endif } } namespace nachia{ template> struct RangeMin{ private: std::vector A; std::vector> spa; CompT comp; int aminf(int a, int b) const { return comp(A[a], A[b]) ? a : b; } public: RangeMin() : comp() {} RangeMin(std::vector a, CompT compt) : A(std::move(a)) , comp(std::move(compt)) { int n = (int)A.size(); int logn = MsbIndex(n) + 1; spa.resize(logn); for(int d=0; d a) : RangeMin(std::move(a), CompT()){} int argmin(int l, int r) const { assert(l < r); int q = MsbIndex(r-l); return aminf(spa[q][l], spa[q][r-(1<> N >> K >> C; vec W(K), P(K); auto graph = nachia::Graph(N, true, K); rep(i,K){ int u,v,w,p; cin >> u >> v >> w >> p; u--; v--; graph[i] = {u,v}; W[i] = w; P[i] = p; } auto mst = nachia::MinimumSpanningForest(graph, *W); i64 mstcost = 0; for(auto e : mst) mstcost += W[e]; if(mstcost > C){ cout << "-1\n"; return; } auto tree = nachia::Graph(N, true); for(auto e : mst) tree.addEdge(graph[e].from, graph[e].to); auto hld = nachia::HeavyLightDecomposition(tree); for(auto& e : tree) if(e.from != hld.parentOf(e.to)) e.reverse(); vec ew(N); rep(i,N-1) ew[tree[i].to] = -W[mst[i]]; auto rq = nachia::RangeMin(ew); i64 ans = 0; for(auto e : mst) chmax(ans, P[e]); rep(k,K){ i64 mincost = 0; auto [u,v] = graph[k]; auto g = hld.lca(u,v); for(auto [l,r] : hld.path(g, u, false)) chmin(mincost, rq.min(l,r)); for(auto [l,r] : hld.path(g, v, false)) chmin(mincost, rq.min(l,r)); mincost += W[k] + mstcost; if(mincost <= C) chmax(ans, P[k]); } cout << ans << '\n'; } int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); #ifdef NACHIA int T; cin >> T; for(int t=0; t