/*
要求一个节点到另一个节点的最大距离，可以分成两类：1.向上找、2.向下找
1.向下找：用dfs_d向下求自每一个节点向下的最大距离即可d1[i]
2.向上找：记u为父节点，j为子节点，此时向上的最大距离 = j->u(w[i]) + 自u出去的最大距离
  2.1.自u向上找最大距离up[u]
  2.2.自u向下找最大距离
      2.2.1.最大距离需要经过子节点j，那么只能用次大距离d2[u]
      2.2.2.最大距离不需要经过子节点j，那么可以使用最大距离d1[u]
*/

#include <iostream>
#include <cstring>

using namespace std;

const int N = 10010 , M = 2 * N , INF = 0x3f3f3f3f;

int e[M] , ne[M] , w[M] , h[N] , idx;
int d1[N] , d2[N] , up[N] , p[N];
bool is_leaf[N];
int n;

void add(int a , int b , int c)
{
    e[idx] = b , ne[idx] = h[a] , w[idx] = c,  h[a] = idx++;
}

int dfs_d(int u , int father)//用子节点更新父节点，返回自u向下的最大距离
{
    d1[u] = -INF , d2[u] = -INF;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        if(j == father) continue;//因为是无向边，所以存在指向父节点的边，所以要排除这种情况
        int d = dfs_d(j , u) + w[i];
        if(d >= d1[u])
        {
            d2[u] = d1[u];
            d1[u] = d;
            p[u] = j; 
        }
        else if(d > d2[u]) d2[u] = d;
    }

    if(d1[u] == -INF) d1[u] = d2[u] = 0 , is_leaf[u] = true;

    return d1[u];
}

void dfs_u(int u, int father)//用父节点更新子节点，返回自u向上的最大距离
{
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;//因为要更新u的子节点，所以忽略父节点

        if (p[u] == j) up[j] = max(up[u], d2[u]) + w[i];//如果子节点在以u向下的最长距离上，则取次大距离
        else up[j] = max(up[u], d1[u]) + w[i];

        dfs_u(j, u);
    }
}

int main()
{
    cin >> n;

    memset(h , -1,  sizeof h);
    for(int i = 0 ; i < n - 1 ; i ++)
    {
        int a ,b , c;
        cin >> a >> b >> c;
        add(a , b , c) , add(b , a , c);
    }

    dfs_d(1 , -1);
    dfs_u(1 , -1);

    int res = d1[1];
    for(int i = 2 ; i <= n ; i++)   res = min(res , max(up[i] , d1[i]));//因为不考虑负权边，所以不用考虑根节点和叶子节点

    cout << res << endl;


    return 0;
}