#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define ITR(x, c) for(__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define all(v) v.begin(), v.end()
#define inputv(v, n)                                                           \
    vl v;                                                                      \
    rep(i, n) {                                                                \
        ll x;                                                                  \
        cin >> x;                                                              \
        v.push_back(x);                                                        \
    }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans = 0;
vector<bool> C(100001,false);
struct Gragh {
    vector<vector<ll>> G;
    ll N;
    vl visited;
    void init(ll n) {
        N = n;
        G.resize(N);
        visited = vl(N, 0);
    }

    void add(ll a, ll b) { G[a].push_back(b); }

    void resetv(void) { visited = vl(N, 0); }

    vl active;
    ll isloop = 0;
    vl toposo;

    vl TOPOSO(void) {
        active.resize(N);
        active = vl(N, 0);
        visited = vl(N, 0);
        rep(i, N) {
            if(visited[i] == 0)
                dfs(i);
        }
        reverse(all(toposo));
        return toposo;
    }

    void dfs(ll x) {
        visited[x] = 1;
        active[x] = 1;
        for(ll i : G[x]) {
            if(visited[i] == 0) {
                dfs(i);
            } else {
                if(active[i] == 1)
                    isloop = 1;
            }
        }
        active[x] = 0;
        toposo.push_back(x);
    }

    vl dag;
    vector<vector<ll>> G2;
    vl DAG(void) {
        resetv();
        G2.resize(N);
        dag.resize(N);
        rep(i, N) {
            for(ll j : G[i]) {
                G2[j].push_back(i);
            }
        }
        ll v = 1;
        rep(i, N) {
            ll j = toposo[i];
            if(visited[j] == 0)
                dfs_dag(j, v);
            v++;
        }
        return dag;
    }

    void dfs_dag(ll x, ll v) {
        C[v]=true;
        dag[x] = v;
        visited[x] = 1;
        for(ll j : G2[x]) {
            if(visited[j] == 0)
                dfs_dag(j, v);
            else if(dag[j]!=v)C[dag[j]]=false;
        }
    }
};
int main() {
    cin >> n;
    Gragh G;
    G.init(n);

    vl A(n);
    rep(i, n) {
        cin >> x >> y;
        G.add(i, y-1);
        A[i]=x*2;
        ans+=A[i];
    }

    G.TOPOSO();

    vl B = G.DAG();

    vl D[n+1];

    rep(i,n){
        D [B[i]].push_back(A[i]);
    }

    ans=ans/2;

    rep(i,n+1){
        sort(all(D[i]));
        if(C[i])ans+=D[i][0]/2;
    }

    cout<<fixed<<setprecision(1)<<float(ans)/2<<endl;
}