// 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;
}