#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using i128 = __int128_t;
using uint = unsigned;
using ull = unsigned long long;
using u128 = __uint128_t;
using pii = pair<int, int>;

int sz(auto&& x) { return int(size(x)); }

const auto& range = views::iota;

// End template

struct Edge {
    int v, w;
    friend auto operator<=>(Edge, Edge) = default;
};

void solve() {
    int n;
    cin >> n;
    vector<vector<Edge>> adj(n);
    for (auto _ : range(0, n - 1)) {
        int u, v, w;
        cin >> u >> v >> w;
        u--, v--;
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w);
    }

    vector dp1(n, 0);
    vector hang(n, 0);
    auto dfs1 = [&](auto&& self, int u) -> void {
        vector paths = {0, 0};
        for (auto [v, w] : adj[u]) {
            erase(adj[v], Edge{u, w});
            self(self, v);
            dp1[u] = max(dp1[u], dp1[v] + w);
        }

        ranges::sort(adj[u], {}, [&](auto e) {
            return dp1[e.v] + e.w;
        });

        for (int j = 0; auto [v, w] : adj[u]) {
            if (j == 2) break;
            hang[u] += dp1[v] + w;
            j++;
        }
    };
    dfs1(dfs1, 0);

    vector dp2(n, 0);
    auto dfs2 = [&](auto&& self, int u) -> void {
        auto m = sz(adj[u]);

        vector pre(m + 1, 0);
        pre[0] = dp2[u];
        for (auto i : range(0, m)) {
            auto [v, w] = adj[u][i];
            pre[i + 1] = max(pre[i], dp1[v] + w);
        }

        vector suf(m + 1, 0);
        for (auto i : range(0, m) | views::reverse) {
            auto [v, w] = adj[u][i];
            suf[i] = max(suf[i + 1], dp1[v] + w);
        }

        for (auto i : range(0, m)) {
            auto [v, w] = adj[u][i];
            dp2[v] = max(pre[i], suf[i + 1]) + w;
            self(self, v);
        }
    };
    dfs2(dfs2, 0);

    int sum = 0;
    for (auto u : range(0, n)) {
        for (auto [v, w] : adj[u]) {
            sum += w;
        }
    }

    int ans = 0;

    for (auto u : range(0, n)) {
        int no_par = 0;
        int par = 0;
        for (int i = 0; auto [v, w] : adj[u]) {
            if (i == 4) break;
            if (i == 3) {
                no_par = par + dp1[v] + w;
            } else {
                par += dp1[v] + w;
            }
            i++;
        }

        ans = max({ans, no_par, par + dp2[u]});
    }

    for (auto u : range(0, n)) {
        auto m = sz(adj[u]);
        for (auto i : range(0, m)) {
            int cur = 0;
            for (int cnt = 0; auto j : range(0, m)) if (j != i) {
                if (cnt == 2) break;
                auto [v, w] = adj[u][j];
                cur += dp1[v] + w;
                cnt++;
            }
            ans = max(ans, cur + hang[ adj[u][i].v ]);
        }
    }

    for (auto u : range(0, n)) {
        vector hangs = {0, 0};
        for (auto [v, w] : adj[u]) {
            hangs.push_back(hang[v]);
        }
        ranges::sort(hangs | views::reverse);
        ans = max(ans, hangs[0] + hangs[1]);
    }

    cout << 2 * sum - ans << '\n';
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    solve();
}