#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#include <iterator>
#include <bitset>
#include <map>
#include <queue>
#define P pair<int, int>
#define x first
#define y second
#define long long long
#define all(x) (x).begin(), (x).end()
#define input() (*istream_iterator<int>(cin))
using namespace std;

const int MAXN = 1e6+5;

int n;
vector<P> g[MAXN];
bitset<MAXN> chk;
bitset<MAXN> incycle;
long sum_ans;

void fastscan(int& x){
    char c = getchar();
    while(isspace(c)){
        c = getchar();
    }
    int out = 0;
    while(isdigit(c)){
        out = out*10 + c - 48;
        c = getchar();
    }
    x = out;
}

void read() {
    fastscan(n);
    for(int i = 1; i <= n; ++i) {
        int a, b;
        fastscan(a), fastscan(b);
        g[a].emplace_back(i, b);
        g[i].emplace_back(a, b);
    }
}

vector<P> in;
int pr;

int dfs(int u, int p) {
    if(chk[u]) {
        in.emplace_back(u, 0);
        incycle[u] = true;
        pr = u;
        return -1;
    }
    chk[u] = true;
    bool havepar = false;
    for(auto v:g[u]) {
        if(!havepar && v.x == p) {
            havepar = true;
            continue;
        }
        int now = dfs(v.x, u);
        if(now == -1) {
            if(pr == u) {
                in[0].y = v.y;
                return 0;
            }
            in.emplace_back(u, v.y);
            incycle[u] = true;
            return -1;
        }
    }
}

long dp[MAXN], mxnow;

long mic(int u, int p) {
    chk[u] = true;
    long mx1 = 0, mx2 = 0;
    for(auto v:g[u]) {
        if(incycle[v.x] || v.x == p) continue;
        long now = mic(v.x, u) + v.y;
        if(now > mx1) swap(mx1, now);
        if(now > mx2) swap(mx2, now);
    }
    mxnow = max(mxnow, mx1 + mx2);
    return mx1;
}

long dpl[2];
long dpll[MAXN], dprr[MAXN];

void solve(int st) {
    mxnow = 0;
    in.clear();
    dfs(st, st);
    for(auto x:in) dp[x.x] = mic(x.x, x.x);
    long dist = 0ll, best = dp[in[0].x];
    int sz = in.size();
    dpll[0] = best, dpl[0] = 0;
    for(int i = 1; i < sz; ++i) {
        dist += in[i].y;
        dpl[i&1] = max(dpl[(i-1)&1], dp[in[i].x] + dist + best);
        dpll[i] = max(dpll[i-1], dp[in[i].x] + dist);
        best = max(best, dp[in[i].x] - dist);
    }
    mxnow = max(mxnow, dpl[(sz-1)&1]);
    dist = 0ll, best = dp[in.back().x];
    dprr[sz-1] = best;
    for(int i = sz-2; i >= 0; --i) {
        dist += in[i+1].y;
        dprr[i] = max(dprr[i+1], dp[in[i].x] + dist);
        best = max(best, dp[in[i].x] - dist);
    }
    long memo = in[0].y;
    for(int i = 0; i < sz-1; ++i)
        mxnow = max(mxnow, dpll[i] + dprr[i+1] + memo);
    sum_ans += mxnow;
}

int main() {
    // freopen("r", "r", stdin);
    cin.sync_with_stdio(false);
    read();
    for(int i = 1; i <= n; ++i) if(!chk[i]) solve(i);
    printf("%lld\n", sum_ans);
}