#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define SPEED ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FOR(i, a, b) for (ll i = a; i < b; ++i)
#define RFOR(i, b, a) for (ll i = b; i >= a; --i)
#define ALL(x) x.begin(), x.end()
#define DEBUG(args...) { string _s = #args; replace(ALL(_s), ' ', '\0');\
replace(ALL(_s), ',', ' ');\
stringstream _ss(_s); istream_iterator<string> _it(_ss); _debug(_it, args);}
#define endl "\n"
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)

using namespace std;
using namespace __gnu_pbds;

template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

void _debug(istream_iterator<string>) {}
template<typename T, typename... Args>
void _debug(istream_iterator<string> it, T first, Args... args) {
    cerr << ">> " << *it << " : " << first << endl; _debug(++it, args...);
}
template <typename T1, typename T2>
inline ostream& operator << (ostream& out, const pair<T1, T2>& p) {
    return out << "(" << p.F << ", " << p.S << ")";
}
template<typename T>
inline ostream& operator << (ostream& out, const vector<T>& v) {
    if (v.empty()) return out << "[]";
    else { out << '['; for (auto& e : v) { out << e << ", "; } return out << "\b\b]"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const set<T>& s) {
    if (s.empty()) return out << "{}";
    else { out << '{'; for (auto& e : s) { out << e << ", "; } return out << "\b\b}"; }
}
template<typename T>
inline ostream& operator << (ostream& out, const unordered_set<T>& s) {
    return out << set<T>(ALL(s));
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const map<T1, T2>& m) {
    if (m.empty()) return out << "{}";
    out << '{'; for (auto& p : m) { out << p << ", "; } return out << "\b\b}";
}
template<typename T1, typename T2>
inline ostream& operator << (ostream& out, const unordered_map<T1, T2>& m) {
    return out << map<T1, T2>(ALL(m));
}
template<typename T>
inline ostream& operator << (ostream& out, const ordered_set<T>& s) {
    return out << set<T>(ALL(s));
}

typedef long long ll;
typedef long double ld;
typedef vector<long long> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef unordered_map<ll, ll> STll;
/************************************** MAIN PROGRAM ********************************************/
/**********************************************************************************
* BINARY INDEXED TREE/FENWICK TREE WITH DEBUGGER  @author: manishjoshi394
**********************************************************************************/
class BIT {
    vector<ll> bit;
    int n;
    void validate(int idx) const {
        if (idx >= n || idx < 0) {
            cerr << "Index out of range in BIT" << endl;
            assert(false);
        }
    }
public:
    BIT(int _n, ll init = 0) {
        this->n = _n;
        bit.resize(n + 1);
        FOR(i, 0, n)
        {
            update(i, init);
        }
    }
    template<typename T>
    BIT(const vector<T>& arr) : BIT(arr.size()) {
        n = arr.size();
        FOR(i, 0, n)
        {
            update(i, arr[i]);
        }
    }
    /// one-indexed
    ll pref_sum(int len) const {
        validate((len > 0) ? len - 1 : 0);
        ll val = 0;
        while (len > 0) {
            val = max(val, bit[len]);
            len -= (len & -len);
        }
        return val;
    }
    /// zero-indexed
    void update(int idx, ll delta) {
        validate(idx);
        idx++;
        while (idx <= n)
        {
            bit[idx] = max(bit[idx], delta);
            idx += (idx & -idx);
        }
    }
    int size() const {
        return bit.size();
    }
};
inline ostream& operator << (ostream& out, const BIT& bit) {
    vector<ll> vals;
    for (int i = 1; i < bit.size(); ++i) {
        vals.push_back(bit.pref_sum(i) - bit.pref_sum(i - 1));
    }
    return out << vals;
}


int main()
{
   // freopen("input.txt", "r", stdin);
    SPEED
    ll n;
    cin >> n;
    vector<ll> h(n);
    vector<ll> a(n);
    for (auto &e : h) {
        cin >> e;
    }
    for (auto &e : a) {
        cin >> e;
    }
    BIT bit(n + 1, 0);
   // seg.update(0, 50);

  //  DEBUG(seg, seg.rmaxq(0, 3))
    vector<ll> dp(n + 1, 0);
    for (int i = 0; i < n; ++i) {
     //   DEBUG(i, dp, seg, "\n")
        dp[h[i]] = a[i];
        dp[h[i]] = max(dp[h[i]], a[i] + bit.pref_sum(h[i]));

        bit.update(h[i], dp[h[i]]);
    }
    cout << *max_element(ALL(dp));
  //  DEBUG(seg.rmaxq(0, 2))
   // DEBUG(seg)
    //DEBUG(dp)
}
/************************************** END OF PROGRAM ******************************************/
/** Stuff you should look for:
 * int overflow, array bounds
 * special cases (n=1?), set/unordered_set TLE, mulitset/set error
 * do something instead of nothing and stay organized
 */


Measured memory_bytes: 6528