#line 1 "main.cpp" //#pragma GCC target("avx,avx2") //#pragma GCC optimize("O3") //#pragma GCC optimize("unroll-loops") #include #ifdef LOCAL #include #define debug(...) debug_print::multi_print(#__VA_ARGS__, __VA_ARGS__) #else #define debug(...) (static_cast(0)) #endif using namespace std; using ll = long long; using ull = unsigned long long; using ld = long double; using pll = pair; using pii = pair; using vi = vector; using vvi = vector; using vvvi = vector; using vl = vector; using vvl = vector; using vvvl = vector; using vul = vector; using vpii = vector; using vpll = vector; using vs = vector; template using pq = priority_queue, greater>; #define overload4(_1, _2, _3, _4, name, ...) name #define overload3(a,b,c,name,...) name #define rep1(n) for (ll UNUSED_NUMBER = 0; UNUSED_NUMBER < (n); ++UNUSED_NUMBER) #define rep2(i, n) for (ll i = 0; i < (n); ++i) #define rep3(i, a, b) for (ll i = (a); i < (b); ++i) #define rep4(i, a, b, c) for (ll i = (a); i < (b); i += (c)) #define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__) #define rrep1(n) for(ll i = (n) - 1;i >= 0;i--) #define rrep2(i,n) for(ll i = (n) - 1;i >= 0;i--) #define rrep3(i,a,b) for(ll i = (b) - 1;i >= (a);i--) #define rrep4(i,a,b,c) for(ll i = (a) + ((b)-(a)-1) / (c) * (c);i >= (a);i -= c) #define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__) #define all1(i) begin(i) , end(i) #define all2(i,a) begin(i) , begin(i) + a #define all3(i,a,b) begin(i) + a , begin(i) + b #define all(...) overload3(__VA_ARGS__, all3, all2, all1)(__VA_ARGS__) #define sum(...) accumulate(all(__VA_ARGS__),0LL) template bool chmin(T &a, const T &b){ if(a > b){ a = b; return 1; } else return 0; } template bool chmax(T &a, const T &b){ if(a < b){ a = b; return 1; } else return 0; } template auto min(const T& a){return *min_element(all(a));} template auto max(const T& a){return *max_element(all(a));} template void in(Ts&... t); #define INT(...) int __VA_ARGS__; in(__VA_ARGS__) #define LL(...) ll __VA_ARGS__; in(__VA_ARGS__) #define STR(...) string __VA_ARGS__; in(__VA_ARGS__) #define CHR(...) char __VA_ARGS__; in(__VA_ARGS__) #define DBL(...) double __VA_ARGS__; in(__VA_ARGS__) #define LD(...) ld __VA_ARGS__; in(__VA_ARGS__) #define VEC(type, name, size) vector name(size); in(name) #define VV(type, name, h, w) vector> name(h, vector(w)); in(name) ll intpow(ll a, ll b){ ll ans = 1; while(b){if(b & 1) ans *= a; a *= a; b /= 2;} return ans;} ll modpow(ll a, ll b, ll p){ ll ans = 1; a %= p;if(a < 0) a += p;while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; } void Yes() {cout << "Yes\n";return;} void No() {cout << "No\n";return;} void YES() {cout << "YES\n";return;} void NO() {cout << "NO\n";return;} void First() {cout << "First\n";return;} void Second() {cout << "Second\n";return;} namespace IO{ #define VOID(a) decltype(void(a)) struct setting{ setting(){cin.tie(nullptr); ios::sync_with_stdio(false);fixed(cout); cout.precision(12);}} setting; template struct P : P{}; template<> struct P<0>{}; template void i(T& t){ i(t, P<3>{}); } void i(vector::reference t, P<3>){ int a; i(a); t = a; } template auto i(T& t, P<2>) -> VOID(cin >> t){ cin >> t; } template auto i(T& t, P<1>) -> VOID(begin(t)){ for(auto&& x : t) i(x); } template void ituple(T& t, index_sequence){in(get(t)...);} template auto i(T& t, P<0>) -> VOID(tuple_size{}){ituple(t, make_index_sequence::value>{});} #undef VOID } #define unpack(a) (void)initializer_list{(a, 0)...} template void in(Ts&... t){ unpack(IO :: i(t)); } #undef unpack static const double PI = 3.1415926535897932; template struct REC { F f; REC(F &&f_) : f(forward(f_)) {} template auto operator()(Args &&...args) const { return f(*this, forward(args)...); }}; //constexpr int mod = 998244353; constexpr int mod = 1000000007; #line 1 "library/data-structure/unionfind.hpp" struct unionfind { public: unionfind() : _n(0) {} explicit unionfind(int n) : _n(n), parent_or_size(n, -1) {} int merge(int a, int b) { assert(0 <= a && a < _n); assert(0 <= b && b < _n); int x = find(a), y = find(b); if (x == y) return x; if (-parent_or_size[x] < -parent_or_size[y]) swap(x, y); parent_or_size[x] += parent_or_size[y]; parent_or_size[y] = x; return x; } bool same(int a, int b) { assert(0 <= a && a < _n); assert(0 <= b && b < _n); return find(a) == find(b); } int find(int a) { assert(0 <= a && a < _n); if (parent_or_size[a] < 0) return a; return parent_or_size[a] = find(parent_or_size[a]); } int size(int a) { assert(0 <= a && a < _n); return -parent_or_size[find(a)]; } vector> groups() { vector leader_buf(_n), group_size(_n); for (int i = 0; i < _n; i++) { leader_buf[i] = find(i); group_size[leader_buf[i]]++; } vector> result(_n); for (int i = 0; i < _n; i++) { result[i].reserve(group_size[i]); } for (int i = 0; i < _n; i++) { result[leader_buf[i]].push_back(i); } result.erase( remove_if(result.begin(), result.end(), [&](const vector& v) { return v.empty(); }), result.end()); return result; } private: int _n; // root node: -1 * component size // otherwise: parent vector parent_or_size; }; #line 2 "library/graph/graph-template.hpp" template struct Edge { int from, to; T cost; Edge() = default; Edge(int _to, T _cost) : from(-1), to(_to), cost(_cost) {} Edge(int _from, int _to, T _cost) : from(_from), to(_to), cost(_cost) {} bool operator < (const Edge &a) const { return cost < a.cost; } bool operator > (const Edge &a) const { return cost > a.cost; } Edge &operator = (const int &x) { to = x; return *this; } operator int() const { return to; } friend ostream operator<<(ostream &os, Edge &edge) { return os << edge.to; } }; template using Edges = vector>; template using Wgraph = vector>; using Ugraph = vector>; Ugraph uinput(int N, int M = -1, bool is_directed = false, int origin = 1) { Ugraph g(N); if (M == -1) M = N - 1; while(M--) { int a,b; cin >> a >> b; a -= origin, b -= origin; g[a].push_back(b); if(!is_directed) g[b].push_back(a); } return g; } template Wgraph winput(int N, int M = -1, bool is_directed = false,int origin = 1) { Wgraph g(N); if (M == -1) M = N - 1; while(M--) { int a,b; T c; cin >> a >> b >> c; a -= origin, b -= origin; g[a].emplace_back(b,c); if(!is_directed) g[b].emplace_back(a,c); } return g; } #line 3 "library/tree/HLD.hpp" template struct HLD { private: void dfs_sz(int cur) { size[cur] = 1; for (auto &dst:g[cur]) { if (dst == par[cur]) { if (g[cur].size() >= 2 && int(dst) == int(g[cur][0])) swap(g[cur][0],g[cur][1]); else continue; } depth[dst] = depth[cur] + 1; par[dst] = cur; dfs_sz(dst); size[cur] += size[dst]; if (size[dst] > size[g[cur][0]]) { swap(dst,g[cur][0]); } } } void dfs_hld(int cur) { down[cur] = id++; for (auto dst:g[cur]) { if (dst == par[cur]) continue; nxt[dst] = (int(dst) == int(g[cur][0]) ? nxt[cur] : int(dst)); dfs_hld(dst); } up[cur] = id; } public: // [u, v) vector> ascend(int u,int v) const { vector> res; while (nxt[u] != nxt[v]) { res.emplace_back(down[u],down[nxt[u]]); u = par[nxt[u]]; } if (u != v) res.emplace_back(down[u],down[v] + 1); return res; } // (u, v] vector> descend(int u,int v) const { if (u == v) return {}; if (nxt[u] == nxt[v]) return {{down[u] + 1,down[v]}}; auto res = descend(u,par[nxt[v]]); res.emplace_back(down[nxt[v]],down[v]); return res; } G& g; int id; vector size,depth,down,up,nxt,par; HLD(G& _g,int root = 0) : g(_g), id(0), size(g.size(),0), depth(g.size(),0), down(g.size(),-1), up(g.size(),-1), nxt(g.size(),root), par(g.size(),root) { dfs_sz(root); dfs_hld(root); } void build(int root) { dfs_sz(root); dfs_hld(root); } pair idx(int i) const {return make_pair(down[i], up[i]);} template void path_query(int u,int v,bool vertex,const F& f) { int l = lca(u,v); for (auto &&[a,b] : ascend(u,l)) { int s = a + 1, t = b; s > t ? f(t,s) : f(s,t); } if (vertex) f(down[l], down[l] + 1); for (auto &&[a,b] : descend(l,v)) { int s = a,t = b + 1; s > t ? f(t,s) : f(s,t); } } template void path_noncommutative_query(int u,int v,bool vertex,const F& f) { int l = lca(u,v); for(auto &&[a,b]:ascend(u,l)) f(a + 1,b); if(vertex) f(down[l],down[l] + 1); for(auto &&[a,b]:descend(l,v)) f(a,b + 1); } template void subtree_query(int u,bool vertex,const F& f) { f(down[u] + int(!vertex), up[u]); } int lca(int a,int b) { while (nxt[a] != nxt[b]) { if (down[a] < down[b]) swap(a, b); a = par[nxt[a]]; } return depth[a] < depth[b] ? a : b; } int dist(int a,int b) {return depth[a] + depth[b] - depth[lca(a, b)] * 2;} }; #line 2 "library/segtree/segtree.hpp" template struct segtree { int N; int size; vector seg; const OP op; const T I; segtree(OP _op, const T &I_) : N(0), size(0), op(_op), I(I_) {} segtree(int _N, OP _op, const T &I_) : op(_op), I(I_) { init(_N); } segtree(const vector &v, OP _op, T I_) : op(_op), I(I_) { init(v.size()); for (int i = 0; i < (int)v.size(); i++) { seg[i + size] = v[i]; } build(); } void init(int _N) { N = _N; size = 1; while (size < N) size <<= 1; seg.assign(2 * size, I); } void build() { for (int k = size - 1; k > 0; k--) { seg[k] = op(seg[2 * k], seg[2 * k + 1]); } } void set(int p, T x) { assert(0 <= p && p < N); p += size; seg[p] = x; while (p >>= 1) { seg[p] = op(seg[2 * p], seg[2 * p + 1]); } } void add(int p, T x) { assert(0 <= p && p < N); p += size; seg[p] += x; while (p >>= 1) { seg[p] = op(seg[2 * p], seg[2 * p + 1]); } } T get(int p) const { assert(0 <= p && p < N); return seg[p + size]; } // query to [l, r) T prod(int l, int r) { assert(0 <= l && l <= r && r <= N); T L = I, R = I; for (l += size, r += size; l < r; l >>= 1, r >>= 1) { if (l & 1) L = op(L, seg[l++]); if (r & 1) R = op(seg[--r], R); } return op(L, R); } T all_prod() {return seg[1];} // check(a[l] * ... * a[r-1]) が true となる最大の r // (右端まですべて true なら N を返す) template int max_right(int l, C check) { assert(0 <= l && l <= N); assert(check(I) == true); if (l == N) return N; l += size; T sm = I; do { while (l % 2 == 0) l >>= 1; if (!check(op(sm, seg[l]))) { while (l < size) { l = (2 * l); if (check(op(sm, seg[l]))) { sm = op(sm, seg[l]); l++; } } return l - size; } sm = op(sm, seg[l]); l++; } while ((l & -l) != l); return N; } // check(a[l] * ... * a[r-1]) が true となる最小の l // (左端まで true なら 0 を返す) template int min_left(int r, C check) { assert(0 <= r && r <= N); assert(check(I) == true); if (r == 0) return 0; r += size; T sm = I; do { r--; while (r > 1 && (r % 2)) r >>= 1; if (!check(op(seg[r], sm))) { while (r < size) { r = (2 * r + 1); if (check(op(seg[r], sm))) { sm = op(seg[r], sm); r--; } } return r + 1 - size; } sm = op(seg[r], sm); } while ((r & -r) != r); return 0; } }; #line 94 "main.cpp" using T = int; T op(T x,T y) {return max(x,y);} T e() {return 0;} int main() { INT(n,k); LL(c); vector> es; rep(i,k) { INT(u,v,w,p); u--,v--; es.emplace_back(u,v,w,p); } vi ord(k); iota(all(ord),0); sort(all(ord),[&](int x,int y){return get<2>(es[x]) < get<2>(es[y]);}); unionfind uf(n); int ans = 0; ll cost = 0; Wgraph g(n); vi used(k); rep(i,k) { if(!uf.same(get<0>(es[ord[i]]),get<1>(es[ord[i]]))) { chmax(ans,get<3>(es[ord[i]])); cost += get<2>(es[ord[i]]); uf.merge(get<0>(es[ord[i]]),get<1>(es[ord[i]])); g[get<0>(es[ord[i]])].emplace_back(get<1>(es[ord[i]]),get<2>(es[ord[i]])); g[get<1>(es[ord[i]])].emplace_back(get<0>(es[ord[i]]),get<2>(es[ord[i]])); used[ord[i]] = 1; } } if(cost > c) { cout << -1 << '\n'; return 0; } HLD> hld(g); vi init(n); auto dfs = REC([&](auto &&f,int now,int par) -> void { for(auto &&nex:g[now]) { if(nex != par) { init[hld.idx(nex).first] = nex.cost; f(nex,now); } } }); dfs(0,-1); segtree seg(init,op,e()); int V = 0; auto f = [&](int u,int v) { chmax(V,seg.prod(u,v)); }; rep(i,k) { if(!used[i]) { V = 0; hld.path_query(get<0>(es[i]),get<1>(es[i]),false,f); if(cost - V + get<2>(es[i]) <= c) { chmax(ans,get<3>(es[i])); } } } cout << ans << '\n'; }