#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int n;
vector<int> a, c;
vector<array<ll, 2>> dp;
vector<vector<int>> adj, radj;
vector<bool> cycle;

void calcdp(int i) {
    for (int j: radj[i]) {
        calcdp(j);
        dp[i][0] += dp[j][1];
        dp[i][1] += min(dp[j][0], dp[j][1]);
    }
    if (a[i] != i) dp[i][1] += c[i];
}

void solve() {
    cin >> n;
    a.resize(n);
    c.resize(n);
    adj.resize(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        adj[i].push_back(--a[i]);
    }
    for (auto &i: c) cin >> i;
    
    // find cycles
    vector<bool> v(n);
    cycle.assign(n, true);
    for (int i = 0; i < n; i++) {
        int j = i;
        while (!v[j]) {
            v[j] = true;
            j = a[j];
        }
        for (int k = i; k != j; k = a[k]) {
            cycle[k] = false;
        }
    }

    radj.resize(n);
    for (int i = 0; i < n; i++) {
        if (!cycle[i]) {
            radj[a[i]].push_back(i);
        }
    }

    // dp
    dp.resize(n);
    for (int i = 0; i < n; i++) {
        if (cycle[i]) calcdp(i);
    }

    // dp but for cycles
    ll ans = 0;
    vector<bool> v2(n);
    for (int i = 0; i < n; i++) {
        if (!cycle[i]) continue;
        if (a[i] == i) {
            ans += dp[i][1];
            continue;
        }
        if (v2[i]) continue;

        vector<int> cyc;
        for (int j = i; !v2[j]; j = a[j]) {
            v2[j] = true;
            cyc.push_back(j);
        }
        int m = cyc.size();

        // i is 0
        array<ll, 2> curdp, prevdp;
        prevdp = {dp[i][0], dp[i][1]};
        for (int k: cyc) {
            if (k == i) continue;
            curdp[0] = prevdp[1] + dp[k][0];
            curdp[1] = min(prevdp[0], prevdp[1]) + dp[k][1];
            swap(curdp, prevdp);
        }
        ll cur0 = prevdp[1];

        // i is 1
        prevdp = {(ll)1e18, dp[i][1]};
        for (int k: cyc) {
            if (k == i) continue;
            curdp[0] = prevdp[1] + dp[k][0];
            curdp[1] = min(prevdp[0], prevdp[1]) + dp[k][1];
            swap(curdp, prevdp);
        }
        ll cur1 = min(prevdp[0], prevdp[1]);
        ans += min(cur0, cur1);
    }

    // ans
    cout << ans << '\n';
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    solve();
}