結果
| 問題 |
No.1833 Subway Planning
|
| コンテスト | |
| ユーザー |
 minato
|
| 提出日時 | 2022-02-27 02:08:29 |
| 言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 635 ms / 4,000 ms |
| コード長 | 14,521 bytes |
| コンパイル時間 | 3,239 ms |
| コンパイル使用メモリ | 222,936 KB |
| 最終ジャッジ日時 | 2025-01-28 03:36:22 |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 23 |
ソースコード
// clang-format off
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vector<T>>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define all(x) begin(x), end(x)
constexpr char ln = '\n';
template <class Container> inline int SZ(const Container& v) { return int(v.size()); }
template <class T> inline void UNIQUE(vector<T>& v) { v.erase(unique(v.begin(), v.end()), v.end()); }
template <class T1, class T2> inline bool chmax(T1& a, T2 b) { if (a < b) { a = b; return true; } return false; }
template <class T1, class T2> inline bool chmin(T1& a, T2 b) { if (a > b) { a = b; return true; } return false; }
inline int topbit(ull x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
inline int botbit(ull x) { return x == 0 ? 64 : __builtin_ctzll(x); }
inline int popcount(ull x) { return __builtin_popcountll(x); }
inline int kthbit(ull x, int k) { return (x >> k) & 1; }
inline constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
inline void YES(bool t = true) { cout << YESNO[t] << "\n"; }
inline void Yes(bool t = true) { cout << YesNo[t] << "\n"; }
template <class T> inline void drop(T x) { cout << x << "\n"; exit(0); }
inline void print() { cout << "\n"; }
template <class T> inline void print(const vector<T>& v) { for (auto it = v.begin(); it != v.end(); ++it) { if (it != v.begin()) { cout << " "; } cout << *it; } print(); }
template <class T, class... Args> inline void print(const T& x, const Args& ... args) { cout << x << " "; print(args...); }
#ifdef MINATO_LOCAL
template <class T1, class T2> ostream& operator<<(ostream& os, pair<T1, T2> p) { return os << "(" << p.first << ", " << p.second << ")"; }
template <size_t N, class TUPLE> void debug_tuple(ostream& os, TUPLE _) { (void)os; (void)_; }
template <size_t N, class TUPLE, class T, class ...Args> void debug_tuple(ostream &os, TUPLE t) { os << (N == 0 ? "" : ", ") << get<N>(t); debug_tuple<N + 1, TUPLE, Args...>(os, t); }
template <class ...Args> ostream& operator<<(ostream& os, tuple<Args...> t) { os << "("; debug_tuple<0, tuple<Args...>, Args...>(os, t); return os << ")"; }
string debug_delim(int& i) { return i++ == 0 ? "" : ", "; }
#define debug_embrace(x) { int i = 0; os << "{"; { x } return os << "}"; }
template <class T> ostream& operator<<(ostream& os, vector<T> v) { debug_embrace( for (T e : v) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> ostream& operator<<(ostream& os, array<T, N> a) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> enable_if_t<!is_same_v<char, remove_cv_t<T>>, ostream>& operator<<(ostream& os, T(&a)[N]) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class Key> ostream& operator<<(ostream& os, set<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class Key, class T> ostream& operator<<(ostream& os, map<Key, T> mp) { debug_embrace( for (auto e : mp) { os << debug_delim(i) << e; }) }
template <class Key> ostream& operator<<(ostream& os, multiset<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class T> ostream& operator<<(ostream& os, queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.front(); } ) }
template <class T> ostream& operator<<(ostream& os, deque<T> q) { debug_embrace( for (T e : q) { os << debug_delim(i) << e; } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T, vector<T>, greater<T>> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
void debug_out() { cerr << endl; }
template <class T, class... Args> void debug_out(const T& x, const Args& ... args) { cerr << " " << x; debug_out(args...); }
#define debug(...) cerr << __LINE__ << " : [" << #__VA_ARGS__ << "] =", debug_out(__VA_ARGS__)
#else
#define debug(...) (void(0))
#endif
struct fast_ios { fast_ios() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20); cerr << fixed << setprecision(7); }; } fast_ios_;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// clang-format on
struct HeavyLightDecomposition {
vector<vector<int>> g;
HeavyLightDecomposition(int n)
: g(n),
n_(n),
vid(n, -1),
head(n),
sub(n, 1),
par(n, -1),
dep(n, 0),
inv(n),
type(n) {}
int size() const { return n_; }
void add_edge(int u, int v) {
g[u].emplace_back(v);
g[v].emplace_back(u);
}
void build(vector<int> rs = {0}) {
int c = 0, pos = 0;
for (int r : rs) {
dfs_sz(r);
head[r] = r;
dfs_hld(r, c++, pos);
}
}
int operator[](int v) const {
assert(0 <= v and v < n_);
return vid[v];
}
int depth(int v) const {
assert(0 <= v and v < n_);
return dep[v];
}
int subtree_size(int v) const {
assert(0 <= v and v < n_);
return sub[v];
}
int parent(int v) const {
assert(0 <= v and v < n_);
return par[v];
}
int kth_ancestor(int v, int k) const {
assert(0 <= v and v < n_);
return kth_ancestor_(v, k);
}
int level_ancestor(int v, int d) const {
assert(0 <= v and v < n_);
return kth_ancestor_(v, dep[v] - d);
}
int lca(int u, int v) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
return lca_(u, v);
}
int distance(int u, int v) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
int w = lca_(u, v);
return distance_(u, v, w);
}
int distance(int u, int v, int w) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
assert(0 <= w and w < n_);
return distance_(u, v, w);
}
int cut_size(int u, int v) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
if (par[u] == v) return sub[u];
if (par[v] == u) return n_ - sub[v];
return -1;
}
int jump(int u, int v, int d) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
return jump_(u, v, d);
}
int step(int u, int v) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
return jump_(u, v, 1);
}
int meet(int u, int v, int w) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
assert(0 <= w and w < n_);
comparator_in(u, v);
comparator_in(v, w);
comparator_in(u, v);
int a = lca_(u, v);
int b = lca_(v, w);
if (dep[a] < dep[b]) return b;
return a;
}
vector<int> path(int u, int v) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
int w = lca_(u, v);
int L = distance_(u, v, w);
vector<int> ret(L + 1);
int it = 0;
while (u != w) {
ret[it++] = u;
u = par[u];
}
it = L;
while (v != w) {
ret[it--] = v;
v = par[v];
}
ret[it] = w;
return ret;
}
template <class F>
void path_query_vertex(int u, int v, const F& f) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
while (true) {
comparator_in(u, v);
f(max(vid[head[v]], vid[u]), vid[v] + 1);
if (head[u] != head[v])
v = par[head[v]];
else
break;
}
}
template <class F>
void path_query_edge(int u, int v, const F& f) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
while (true) {
comparator_in(u, v);
if (head[u] != head[v]) {
f(vid[head[v]], vid[v] + 1);
v = par[head[v]];
} else {
if (u != v) f(vid[u] + 1, vid[v] + 1);
break;
}
}
}
template <class F>
void subtree_query_vertex(int v, const F& f) const {
assert(0 <= v and v < n_);
f(vid[v], vid[v] + sub[v]);
}
template <class F>
void subtree_query_edge(int v, const F& f) const {
assert(0 <= v and v < n_);
f(vid[v] + 1, vid[v] + sub[v]);
}
template <class T, class F, class M>
T noncommutative_query_vertex(int u, int v, T e, const F& f,
const M& op) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
int w = lca_(u, v);
T resl = e, resr = e;
while (true) {
resl = op(resl, f(vid[u] + 1, max(vid[head[u]], vid[w])));
if (head[w] != head[u])
u = par[head[u]];
else
break;
}
while (true) {
if (head[w] != head[v]) {
resr = op(f(vid[head[v]], vid[v] + 1), resr);
v = par[head[v]];
} else {
if (w != v) resr = op(f(vid[w] + 1, vid[v] + 1), resr);
break;
}
}
return op(resl, resr);
}
template <class T, class F, class M>
T noncommutative_query_edge(int u, int v, T e, const F& f,
const M& op) const {
assert(0 <= u and u < n_);
assert(0 <= v and v < n_);
int w = lca_(u, v);
T resl = e, resr = e;
while (true) {
if (head[w] != head[u]) {
resl = op(resl, f(vid[u] + 1, vid[head[u]]));
u = par[head[u]];
} else {
if (w != u) resl = op(resl, f(vid[u] + 1, vid[w] + 1));
break;
}
}
while (true) {
if (head[w] != head[v]) {
resr = op(f(vid[head[v]], vid[v] + 1), resr);
v = par[head[v]];
} else {
if (w != v) resr = op(f(vid[w] + 1, vid[v] + 1), resr);
break;
}
}
return op(resl, resr);
}
private:
int n_;
vector<int> vid, head, sub, par, dep, inv, type;
void dfs_sz(int v) {
vector<int>& es = g[v];
if (~par[v]) es.erase(find(es.begin(), es.end(), par[v]));
for (int& u : es) {
par[u] = v;
dep[u] = dep[v] + 1;
dfs_sz(u);
sub[v] += sub[u];
if (sub[u] > sub[es[0]]) swap(u, es[0]);
}
}
void dfs_hld(int v, int c, int& pos) {
vid[v] = pos++;
inv[vid[v]] = v;
type[v] = c;
for (int u : g[v]) {
if (u == par[v]) continue;
head[u] = (u == g[v][0] ? head[v] : u);
dfs_hld(u, c, pos);
}
}
void comparator_in(int& u, int& v) const {
if (vid[u] > vid[v]) swap(u, v);
}
int kth_ancestor_(int v, int k) const {
if (dep[v] < k or k < 0) return -1;
while (true) {
if (dep[v] - dep[head[v]] + 1 <= k) {
k -= dep[v] - dep[head[v]] + 1;
v = par[head[v]];
} else {
return inv[vid[v] - k];
}
}
}
int lca_(int u, int v) const {
while (true) {
comparator_in(u, v);
if (head[u] == head[v]) return u;
v = par[head[v]];
}
}
int distance_(int u, int v, int w) const {
return dep[u] + dep[v] - 2 * dep[w];
}
int jump_(int u, int v, int d) const {
int w = lca_(u, v);
int L = distance_(u, v, w);
if (L < d) return -1;
if (d <= distance_(u, w, w)) return kth_ancestor_(u, d);
return kth_ancestor_(v, L - d);
}
};
using Tu = tuple<int, int, int>;
int main() {
int N;
cin >> N;
if (N == 2) drop(0);
HeavyLightDecomposition HLD(N);
map<pii, int> dic;
vec<Tu> es;
rep(i, N - 1) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (a > b) swap(a, b);
HLD.add_edge(a, b);
dic[pii(a, b)] = c;
es.emplace_back(c, a, b);
}
HLD.build();
sort(all(es));
reverse(all(es));
int u = 0, v = 0;
int mx = 0, mn = 1e9;
int ans = 1e9;
{
auto [c, a, b] = es[0];
u = a;
v = b;
mx = c;
mn = c;
auto [d, e, f] = es[1];
ans = d;
}
for (int i = 1; i < N - 1; i++) {
auto [c, a, b] = es[i];
int meet_a = HLD.meet(u, v, a);
int meet_b = HLD.meet(u, v, b);
debug(u, v, a, b, meet_a, meet_b);
if (meet_a != u and meet_a != v and meet_a != a) break;
if (meet_b != u and meet_b != v and meet_b != b) break;
if (meet_a == u and meet_b == u) {
int s = u;
int t = (HLD.distance(u, a) > HLD.distance(u, b) ? a : b);
while (s != t) {
debug(s, t);
int w = HLD.step(s, t);
{
int p = s;
int q = w;
if (p > q) swap(p, q);
int cost = dic[pii(p, q)];
chmin(mn, cost);
}
s = w;
}
u = s;
} else if (meet_a == v and meet_b == v) {
int s = v;
int t = (HLD.distance(v, a) > HLD.distance(v, b) ? a : b);
while (s != t) {
int w = HLD.step(s, t);
{
int p = s;
int q = w;
if (p > q) swap(p, q);
int cost = dic[pii(p, q)];
chmin(mn, cost);
}
s = w;
}
v = s;
}
chmin(ans, max(mx - mn, i < N - 1 ? get<0>(es[i + 1]) : 0));
}
cout << ans << ln;
}