#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
#define Cint boost::multiprecision::cpp_int
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
#define dump(x)                             \
    if (dbg) {                              \
        cerr << #x << " = " << (x) << endl; \
    }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
namespace mydef {
const int INF = 1ll << 60;
const int MOD = 1e9 + 7;
template <class T>
bool chmin(T& a, const T& b) {
    if (a > b) {
        a = b;
        return 1;
    } else
        return 0;
}
template <class T>
bool chmax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return 1;
    } else
        return 0;
}
void Yes(bool flag = true) {
    if (flag)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
}
void No(bool flag = true) {
    Yes(!flag);
}
void YES(bool flag = true) {
    if (flag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
void NO(bool flag = true) {
    YES(!flag);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val) {
    std::fill((T*)array, (T*)(array + N), val);
}
bool dbg = true;
}  // namespace mydef
using namespace mydef;
#define pb push_back
//#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<pair<int, int>>
#define vvp vector<vector<pair<int, int>>>
#define pi pair<int, int>
//#define P pair<int, int>
//#define V vector<int>
//#define S set<int>
#define asn ans

template <typename T>
struct edge {
    int to, id;
    T cost;
    edge(int to) : to(to), id(-1), cost(1) {}
    edge(int to, T cost) : to(to), id(-1), cost(cost) {}
    edge(int to, T cost, int id) : to(to), id(id), cost(cost) {}
    operator int() const { return to; }
    /*
        edge& operator=(const int& x) {
            to = x;
            return *this;
        }
        */
};
template <typename T>
class Graph : public vector<vector<edge<T>>> {
    //--------Basic--------
private:
    using Edge = edge<T>;
    int M;  //M:辺の数
    bool undirected = false;
    bool directed = false;
    bool unweighted = false;
    bool weighted = false;
    bool tree = false;
    //
public:
    //
public:
    Graph() = default;
    //unweighted
    void add_edge_undirected(int u, int v, int id = -1) {
        assert(!directed);
        assert(!weighted);
        undirected = true;
        unweighted = true;
        (*this)[u].emplace_back(Edge{v, 1, id});
        (*this)[v].emplace_back(Edge{u, 1, id});
    }
    void build_undirected(int m) {
        assert(!(*this).empty());
        assert(!directed);
        assert(!weighted);
        undirected = true;
        unweighted = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            cin >> u >> v;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, 1, i});
            (*this)[v].emplace_back(Edge{u, 1, i});
        }
    }
    void build_undirected(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    void add_edge_directed(int u, int v, int id = -1) {
        assert(!undirected);
        assert(!weighted);
        directed = true;
        unweighted = true;
        (*this)[u].emplace_back(Edge{v, 1, id});
    }
    void build_directed(int m) {
        assert(!(*this).empty());
        assert(!undirected);
        assert(!weighted);
        directed = true;
        unweighted = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            cin >> u >> v;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, 1, i});
        }
    }
    void build_directed(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    //weighed
    void add_edge_undirected_weighed(int u, int v, T cost, int id = -1) {
        assert(!directed);
        assert(!unweighted);
        undirected = true;
        weighted = true;
        (*this)[u].emplace_back(Edge{v, cost, id});
        (*this)[v].emplace_back(Edge{u, cost, id});
    }
    void build_undirected_weighted(int m) {
        assert(!(*this).empty());
        assert(!directed);
        assert(!unweighted);
        undirected = true;
        weighted = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            T cost;
            cin >> u >> v >> cost;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, cost, i});
            (*this)[v].emplace_back(Edge{u, cost, i});
        }
    }
    void build_undirected_weighted(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    void add_edge_directed_weighted(int u, int v, T cost, int id = -1) {
        assert(!undirected);
        assert(!unweighted);
        directed = true;
        weighted = true;
        (*this)[u].emplace_back(Edge{v, cost, id});
    }
    void build_directed_weighted(int m) {
        assert(!(*this).empty());
        assert(!undirected);
        assert(!unweighted);
        directed = true;
        weighted = true;
        M = m;
        for (int i = 0; i < m; i++) {
            int u, v;
            T cost;
            cin >> u >> v >> cost;
            u--;
            v--;
            (*this)[u].emplace_back(Edge{v, cost, i});
        }
    }
    void build_directed_weighted(int n, int m) {
        (*this).resize(n);
        build_undirected(m);
    }
    //tree
    void istree() {
        tree = true;
    }
    void build_tree(int n) {
        istree();
        build_undirected(n, n - 1);
    }
    void build_tree_weighted(int n) {
        istree();
        build_undirected_weighted(n, n - 1);
    }
    //print state
    void state() {
        cerr << endl
             << "Print State" << endl
             << "Edge :" << endl
             << "    Directed   : " << (directed ? "Yes" : "No") << endl
             << "    Undirected : " << (undirected ? "Yes" : "No") << endl
             << "    Weighted   : " << (weighted ? "Yes" : "No") << endl
             << "    Unweighted : " << (unweighted ? "Yes" : "No") << endl
             << "    Tree       : " << (tree ? "Yes" : "No") << endl
             << "Usable Functions" << endl
             << "    StronglyConnectedComponent(unverified): " << (StronglyConnectedComponent_ready ? "Yes" : "No") << endl;
    }
    //
    //
    //
    //--------StronglyConnectedComponent--------
    //Unverified
public:
    vector<vector<int>> SCC_R, SCC_T;
    //
private:
    bool StronglyConnectedComponent_ready = false;
    vector<int> SCC_cmp, SCC_ord;
    vector<bool> SCC_used;
    //
public:
    int SCC_build() {
        cerr << "Please Verify" << endl;
        assert(!undirected);
        assert(directed);
        int N = (*this).size();
        SCC_R.resize(N);
        for (int i = 0; i < N; i++) {
            for (int& x : (*this)[i]) {
                SCC_R[x].emplace_back(i);
            }
        }
        SCC_cmp.resize(N);
        fill(SCC_cmp.begin(), SCC_cmp.end(), -1);
        SCC_used.resize(N);
        fill(SCC_used.begin(), SCC_used.end(), false);
        StronglyConnectedComponent_ready = true;
        return build_StronglyConnectedComponent_init();
    }
    int SCC(int k) {
        assert(StronglyConnectedComponent_ready);
        return SCC_cmp[k];
    }
    //
private:
    void dfs(int now) {
        if (SCC_used[now])
            return;
        SCC_used[now] = true;
        for (auto nxt : (*this)[now])
            dfs(nxt);
        SCC_ord.emplace_back(now);
    }
    void rdfs(int now, int count) {
        if (SCC_cmp[now] != -1)
            return;
        SCC_cmp[now] = count;
        for (auto to : SCC_R[now])
            rdfs(to, count);
    }
    int build_StronglyConnectedComponent_init() {
        int n = (int)(*this).size();
        for (int i = 0; i < n; i++)
            dfs(i);
        reverse(SCC_ord.begin(), SCC_ord.end());
        int group = 0;
        for (auto& i : SCC_ord) {
            if (SCC_cmp[i] == -1) {
                rdfs(i, group);
                group++;
            }
        }
        SCC_T.resize(group);
        for (int i = 0; i < n; i++) {
            for (auto& to : (*this)[i]) {
                int s = SCC_cmp[i], t = SCC_cmp[to];
                if (s != t)
                    SCC_T[s].emplace_back(t);
            }
        }
        return group;
    }
    //
    //
    //
    //--------TopologicalSort--------
    //未実装
    //
    //
    //
    //--------Tree--------
    //
    //
    //--------ReRooting--------
    //unverified
private:
    template <typename sum_t>
    void ReRooting_dfs_sub(int idx, int par,
        const function<sum_t(sum_t, sum_t)>& f,
        const function<sum_t(sum_t, Edge)>& gg,
        const sum_t& ident,
        vector<sum_t>& subdp,
        vector<sum_t>& dp,
        vector<vector<sum_t>>& g_dp,
        vector<vector<sum_t>>& g_ndp,
        vector<vector<sum_t>>& memo,
        vector<vector<bool>>& seen) {
        for (int i = 0; i < (int)((*this)[idx].size()); i++) {
            auto& e = (*this)[idx][i];
            if (e.to == par)
                continue;
            ReRooting_dfs_sub<sum_t>(e.to, idx, f, gg, ident, subdp, dp, g_dp, g_ndp, memo, seen);
            if (!seen[idx][i]) {
                memo[idx][i] = gg(subdp[e.to], e);
                seen[idx][i] = true;
            }
            subdp[idx] = f(subdp[idx], memo[idx][i]);
        }
    }
    template <typename sum_t>
    void ReRooting_dfs_all(int idx, int par, const sum_t& top,
        const function<sum_t(sum_t, sum_t)>& f,
        const function<sum_t(sum_t, Edge)>& gg,
        const sum_t& ident,
        vector<sum_t>& subdp,
        vector<sum_t>& dp,
        vector<vector<sum_t>>& g_dp,
        vector<vector<sum_t>>& g_ndp,
        vector<vector<sum_t>>& memo,
        vector<vector<bool>>& seen) {
        sum_t buff{ident};
        for (int i = 0; i < (int)((*this)[idx].size()); i++) {
            auto& e = (*this)[idx][i];
            g_ndp[idx][i] = buff;
            if (!seen[idx][i]) {
                memo[idx][i] = gg(par == e.to ? top : subdp[e.to], e);
                seen[idx][i] = true;
            }
            g_dp[idx][i] = memo[idx][i];
            buff = f(buff, g_dp[idx][i]);
        }
        dp[idx] = buff;
        buff = ident;
        for (int i = (*this)[idx].size() - 1; i >= 0; i--) {
            auto& e = (*this)[idx][i];
            if (e.to != par)
                ReRooting_dfs_all<sum_t>(e.to, idx, f(g_ndp[idx][i], buff), f, gg, ident, subdp, dp, g_dp, g_ndp, memo, seen);
            g_ndp[idx][i] = f(g_ndp[idx][i], buff);
            buff = f(buff, g_dp[idx][i]);
        }
    }
    //
public:
    template <typename sum_t>
    pair<vector<sum_t>, vector<vector<sum_t>>> Tbuild_ReRooting(
        const function<sum_t(sum_t, sum_t)> f,
        const function<sum_t(sum_t, Edge)> gg,
        sum_t ident) {
        assert(tree);
        int N = (*this).size();
        vector<sum_t> subdp(N, ident), dp(N, ident);
        vector<vector<sum_t>> g_dp(N), g_ndp(N), memo(N);
        vector<vector<bool>> seen(N);
        for (int i = 0; i < N; i++) {
            int S = (*this)[i].size();
            g_dp[i].resize(S, ident);
            g_ndp[i].resize(S, ident);
            memo[i].resize(S);
            seen[i].resize(S, false);
        }
        //ReRooting_dfs_sub<sum_t>(0, -1, f, gg, ident, subdp, dp, g_dp, g_ndp, memo, seen);

        stack<int> stk;
        stk.push(0);
        vector<int> par(N), ord(N);
        int index = 0;
        par[0] = -1;
        while (!stk.empty()) {
            int node = stk.top();
            stk.pop();
            ord[index++] = node;
            for (auto& e : (*this)[node]) {
                if (e.to == par[node])
                    continue;
                stk.push(e.to);
                par[e.to] = node;
            }
        }
        for (int k = ord.size() - 1; k >= 0; k--) {
            int idx = ord[k];

            for (int i = 0; i < (int)((*this)[idx].size()); i++) {
                auto& e = (*this)[idx][i];
                if (e.to == par[idx])
                    continue;
                if (!seen[idx][i]) {
                    memo[idx][i] = gg(subdp[e.to], e);
                    seen[idx][i] = true;
                }
                subdp[idx] = f(subdp[idx], memo[idx][i]);
            }
        }


        ReRooting_dfs_all<sum_t>(0, -1, ident, f, gg, ident, subdp, dp, g_dp, g_ndp, memo, seen);
        return make_pair(dp, memo);
    }
};
//グローバルでの使用のみ想定

int N, A[201010], B[201010], C[201010];
const int geta = 200000;
vp memo;

Graph<int> G;

void solve() {
    memo.resize(N - 1);
    /*
    ReRooting<int, int> G(
        N,
        [](int a, int b) { return a + b; },
        [&](int a, int b) {
            cerr << b << endl;
            if (b >= geta) {
                b -= geta;
                memo[b].second = a + 1;
            } else {
                memo[b].first = a + 1;
            }
            return a + 1;
        },
        0ll);

    for (int i = 0; i < N - 1; i++) {
        G.add_edge_bi(A[i], B[i], i, i + geta);
    }
    G.build();
        */

    G.istree();
    G.state();
    G.Tbuild_ReRooting<int>(
        [](int a, int b) { return a + b; },
        [&](int a, edge<int> e) {
            int b = e.id;
            if (b >= geta) {
                b -= geta;
                memo[b].second = a + 1;
            } else {
                memo[b].first = a + 1;
            }
            return a + 1;
        },
        0ll);

    int ans = 0;

    int id = -1;
    int MIN_cnt = INF;
    for (int i = 0; i < N - 1; i++) {
        auto p = memo[i];
        chmin(MIN_cnt, abs(p.first - p.second));
    }
    for (int i = 0; i < N - 1; i++) {
        auto p = memo[i];
        if (MIN_cnt == abs(p.first - p.second)) {
            if (p.first - p.second == MIN_cnt)
                id = B[i];
            else
                id = A[i];
        }
    }
    dump(id);
    dump(MIN_cnt);
    int MIN = INF;
    for (int i = 0; i < N - 1; i++) {
        auto p = memo[i];
        ans += C[i] * min(p.first, p.second) * 2;
        if (MIN_cnt > 0) {
            if (A[i] == id || B[i] == id) {
                chmin(MIN, C[i]);
            }
        } else {
            if (p.first == p.second)
                MIN = C[i];
        }
        /*
            if (S.count(i)) {
                chmin(MIN, C[i]);
            }
            */
    }
    ans -= MIN;
    cout << ans << endl;
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    cin >> N;
    G.resize(N);
    for (int i = 0; i < N - 1; i++) {
        cin >> A[i] >> B[i] >> C[i];
        A[i]--;
        B[i]--;
        G.add_edge_directed(A[i], B[i], i);
        G.add_edge_directed(B[i], A[i], i + geta);
    }

    solve();
    return 0;
}


Measured memory_bytes: 79148