#include <bits/stdc++.h>

using namespace std;

int main() {
  int n; cin >> n;
  vector<vector<int>> graph(n);
  vector<tuple<int, int, int>> edges;
  for (int i = 1; i < n; ++i) {
    int a, b, c; cin >> a >> b >> c;
    graph[a - 1].push_back(b - 1);
    graph[b - 1].push_back(a - 1);
    edges.emplace_back(c, a - 1, b - 1);
  }
  long long ans = 0;

  sort(edges.begin(), edges.end());
  int to_rem = 0;
  vector<bool> still(n, true);
  vector<int> tag(n, -1);
  int at = 0;
  int total_sz = n;
  while (edges.size()) {
    int c, a, b; tie(c, a, b) = edges.back(); edges.pop_back();
    if (!still[a] || !still[b]) continue;

    ++at;
    vector<int> nodes[2];
    int rem[2] = {0, 0};
    vector<tuple<int, int, int>> q;

    auto push = [&](int node, int b) {
      if (!still[node]) return;
      if (tag[node] == at) return;
      tag[node] = at;
      rem[b] += 1;
      nodes[b].push_back(node);
      q.emplace_back(b, node, 0);
    };

    push(a, 0);
    push(b, 1);

    for (int i = 0; rem[0] && rem[1]; ++i) {
      int b, node, idx; tie(b, node, idx) = q[i];
      if (idx < (int)graph[node].size()) {
        push(graph[node][idx], b);
        q.emplace_back(b, node, idx + 1);
      } else {
        rem[b] -= 1;
      }
    }

    if (nodes[1].size() < nodes[0].size())
      swap(nodes[0], nodes[1]);
    int left_sz = nodes[0].size();
    int right_sz = total_sz - left_sz;

    if (left_sz + to_rem >= right_sz - 1) {
      ans += (1LL * (total_sz - to_rem - 1)) << c;
      break;
    } else {
      ans += (2LL * left_sz) << c;
      to_rem += left_sz;
      for (auto x : nodes[0]) {
        still[x] = false;
        total_sz -= 1;
      }
    }
  }

  cout << ans << endl;
  return 0;
}