#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
// --------------------------------------------------------
#define FOR(i,l,r) for (ll i = (l); i < (r); ++i)
#define RFOR(i,l,r) for (ll i = (r)-1; (l) <= i; --i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define SUMLL(c) accumulate(ALL(c), 0LL)
#define COUNT(c,v) count(ALL(c),(v))
#define SZ(c) ((ll)(c).size())
#define BIT(b,i) (((b)>>(i)) & 1)
#define PCNT(b) __builtin_popcountll(b)
#define P0(i) (((i) & 1) == 0)
#define P1(i) (((i) & 1) == 1)
#ifdef _LOCAL
    #define debug_bar cerr << "--------------------\n";
    #define debug(x) cerr << "l." << __LINE__ << " : " << #x << " = " << (x) << '\n'
    #define debug_pair(x) cerr << "l." << __LINE__ << " : " << #x << " = (" << x.first << "," << x.second << ")\n";
    template<class T> void debug_line(const vector<T>& ans, int l, int r, int L = 0) { cerr << "l." << L << " :"; for (int i = l; i < r; i++) { cerr << ' ' << ans[i]; } cerr << '\n'; }
#else
    #define cerr if (false) cerr
    #define debug_bar
    #define debug(x)
    #define debug_pair(x)
    template<class T> void debug_line([[maybe_unused]] const vector<T>& ans, [[maybe_unused]] int l, [[maybe_unused]] int r, [[maybe_unused]] int L = 0) {}
#endif
template<class... T> void input(T&... a) { (cin >> ... >> a); }
void print() { cout << '\n'; }
template<class T> void print(const T& a) { cout << a << '\n'; }
template<class T, class... Ts> void print(const T& a, const Ts&... b) { cout << a; (cout << ... << (cout << ' ', b)); cout << '\n'; }
template<class T> void cout_line(const vector<T>& ans, int l, int r) { for (int i = l; i < r; i++) { if (i != l) { cout << ' '; } cout << ans[i]; } cout << '\n'; }
template<class T> bool chmin(T& a, const T b) { if (b < a) { a = b; return 1; } return 0; }
template<class T> bool chmax(T& a, const T b) { if (a < b) { a = b; return 1; } return 0; }
pair<ll,ll> divmod(ll a, ll b) { assert(a >= 0 && b > 0); return make_pair(a / b, a % b); }
ll mod(ll x, ll m) { assert(m != 0); return (x % m + m) % m; }
ll llceil(ll a, ll b) { if (b < 0) { return llceil(-a, -b); } assert(b > 0); return (a < 0 ? a / b : (a + b - 1) / b); }
ll llfloor(ll a, ll b) { if (b < 0) { return llfloor(-a, -b); } assert(b > 0); return (a > 0 ? a / b : (a - b + 1) / b); }
ll llpow(ll x, ll n) { assert(n >= 0); if (n == 0) { return 1; }; ll res = llpow(x, n>>1); res *= res; if (n & 1) { res *= x; } return res; }
ll bitlen(ll b) { if (b <= 0) { return 0; } return (64LL - __builtin_clzll(b)); }
ll digit_len(ll n) { assert(n >= 0); if (n == 0) { return 1; } ll sum = 0; while (n > 0) { sum++; n /= 10; } return sum; }
ll digit_sum(ll n) { assert(n >= 0); ll sum = 0; while (n > 0) { sum += n % 10; n /= 10; } return sum; }
ll digit_prod(ll n) { assert(n >= 0); if (n == 0) { return 0; } ll prod = 1; while (n > 0) { prod *= n % 10; n /= 10; } return prod; }
ll xor_sum(ll x) { assert(0 <= x); switch (x % 4) { case 0: return x; case 1: return 1; case 2: return x ^ 1; case 3: return 0; } assert(false); }
string toupper(const string& S) { string T(S); for (int i = 0; i < (int)T.size(); i++) { T[i] = toupper(T[i]); } return T; }
string tolower(const string& S) { string T(S); for (int i = 0; i < (int)T.size(); i++) { T[i] = tolower(T[i]); } return T; }
int a2i(const char& c) { assert(islower(c)); return (c - 'a'); }
int A2i(const char& c) { assert(isupper(c)); return (c - 'A'); }
int d2i(const char& d) { assert(isdigit(d)); return (d - '0'); }
char i2a(const int& i) { assert(0 <= i && i < 26); return ('a' + i); }
char i2A(const int& i) { assert(0 <= i && i < 26); return ('A' + i); }
char i2d(const int& i) { assert(0 <= i && i <= 9); return ('0' + i); }
using P = pair<ll,ll>;
using VP = vector<P>;
using VVP = vector<VP>;
using VS = vector<string>;
using VVS = vector<VS>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VVVLL = vector<VVLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VVVB = vector<VVB>;
using VD = vector<double>;
using VVD = vector<VD>;
using VVVD = vector<VVD>;
using VLD = vector<ld>;
using VVLD = vector<VLD>;
using VVVLD = vector<VVLD>;
const ld EPS = 1e-10;
const ld PI  = acosl(-1.0);
constexpr ll MOD = 1000000007;
// constexpr ll MOD = 998244353;
constexpr int inf = (1 << 30) - 1;   // 1073741824 - 1
constexpr ll INF = (1LL << 62) - 1;  // 4611686018427387904 - 1
// --------------------------------------------------------
// #include <atcoder/all>
// using namespace atcoder;



/** NOTE: 軽量版 Functional Graph（ML が厳しい Codeforces 向け） **/

// References:
//   <https://usaco.guide/CPH.pdf#page=164>
//   <https://usaco.guide/problems/cses-1160-planets-queries-ii/solution>

struct FunctionalGraph {
  public:
    // 連携成分の数
    int C = 0;
    // 頂点 u が属する連結成分の番号
    vector<int> comp;
    // 頂点 u が属する木の根（サイクルにも属する頂点は自身が根）
    vector<int> root;
    // 頂点 u の根からの深さ
    vector<int> depth;
    // 連結成分 c に含まれるサイクル長
    vector<int> cycle_length;

    vector<int> f;  // 頂点 u から出る有向辺 (to, weight)
    vector<vector<int>> Gr;  // 逆辺グラフ

    FunctionalGraph(int n) : N(n) {
        f.resize(N);
        Gr.resize(N);
        comp.resize(N,-1);
        root.resize(N,-1);
        depth.resize(N,0);
    }

    // 有向辺を追加する
    void add_edge(int u, int v) {
        assert(0 <= u && u < N);
        assert(0 <= v && v < N);
        f[u] = v;
        Gr[v].push_back(u);
    }

    // 前計算を行う（連結成分分解・サイクル検出など）
    void build() {
        // 連結成分分解とサイクル検出
        for (int s = 0; s < N; s++) if (root[s] == -1) {
            // サイクル検出
            auto [x, length] = cycle_detection(s);
            cycle_length.push_back(length);

            // サイクル上の頂点をチェック
            int r = x;
            for (int i = 0; i < length; i++) {
                root[r] = r; r = f[r];
            }

            // 木上の頂点をチェック
            for (int i = 0; i < length; i++) {
                auto dfs = [&](auto&& self, int u, int d) -> void {
                    root[u] = r; comp[u] = C; depth[u] = d;
                    for (const auto& v : Gr[u]) if (root[v] == -1) {
                        self(self, v, d + 1);
                    }
                };
                dfs(dfs, r, 0);
                r = f[r];
            }
            C++;
        }
    }

    // 連結成分ごとの頂点リストを返す
    vector<vector<int>> groups() const {
        vector<vector<int>> g(C);
        for (int u = 0; u < N; u++) {
            g[comp[u]].push_back(u);
        }
        return g;
    }

    // 頂点 u がサイクルに属しているか判定（木の根もサイクルに属するとみなされる）
    bool on_cycle(int u) const {
        assert(0 <= u && u < N);
        return (root[u] == u);
    }

    // 頂点 u, v が同じ連結成分に属しているか判定
    bool same_comp(int u, int v) const {
        assert(0 <= u && u < N);
        assert(0 <= v && v < N);
        return (comp[u] == comp[v]);
    }

    // 頂点 u, v が同じ木に属しているか判定
    bool same_tree(int u, int v) const {
        assert(0 <= u && u < N);
        assert(0 <= v && v < N);
        return (root[u] == root[v]);
    }

    // 頂点 u, v が同じサイクルに属しているか判定
    bool same_cycle(int u, int v) const {
        assert(0 <= u && u < N);
        assert(0 <= v && v < N);
        return (same_comp(u, v) && on_cycle(u) && on_cycle(v));
    }

  private:
    int N;  // 頂点数

    // Functional Graph におけるサイクル検出 (Floyd's cycle-finding algorithm)
    // (サイクルに属する頂点の一つ, サイクル長) のペアを返す
    pair<int,int> cycle_detection(int x) const {
        int a = f[x];
        int b = f[f[x]];
        while (a != b) {
            a = f[a];
            b = f[f[b]];
        }
        b = f[a];
        int length = 1;
        while (a != b) {
            b = f[b];
            length++;
        }
        return make_pair(a, length);
    }
};


int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    int N; cin >> N;
    FunctionalGraph fg(N);
    const auto& f = fg.f;
    const auto& Gr = fg.Gr;
    VI L(N),S(N); REP(i,N) input(L[i], S[i]);
    REP(u,N) {
        int v = S[u] - 1;
        fg.add_edge(u, v);
    }
    fg.build();

    VB vis(N,false);
    double ans = 0;
    REP(u,N) {
        if (vis[u]) continue;
        int root = fg.root[u];
        // サイクル上の頂点において L の最小を求める
        int tmp = inf;
        int pos = root;
        int x = -1;
        while (true) {
            if (chmin(tmp, L[pos])) x = pos;
            pos = f[pos];
            if (pos == root) break;
        }

        auto dfs = [&](auto&& self, int u, int p) -> void {
            vis[u] = true;
            ans += L[u] / 2.0;
            for (const auto& v : Gr[u]) if (v != p) {
                if (vis[v]) continue;
                self(self, v, u);
            }
        };
        dfs(dfs, x, -1);
        ans += L[x] / 2.0;
    }
    printf("%.1f\n", ans);

    return 0;
}