// Original C++ solution (slower):
#include <bits/stdc++.h>



#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)

#define RFOR(i,a) for(int i=(a); i >= 0; --i)

#define FOE(i,a) for(auto i : a)

#define ALL(c) (c).begin(), (c).end()

#define RALL(c) (c).rbegin(), (c).rend()

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define SUM(x) std::accumulate(ALL(x), 0LL)

#define MIN(v) *std::min_element(v.begin(), v.end())

#define MAX(v) *std::max_element(v.begin(), v.end())

#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())

#define BIT_ON(bit, i) (bit & (1LL << i))

#define BIT_COUNT(bit) (__builtin_popcount(bit))



typedef long long LL;

template<typename T> using V = std::vector<T>;

template<typename T> using VV = std::vector<std::vector<T>>;

template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;

template<typename T> using VVVV = std::vector<std::vector<std::vector<std::vector<T>>>>;



template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }

template<class T> inline void print(T x) { std::cout << x << std::endl; }

template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }

template<class T> inline void print_2vec(const std::vector<std::vector<T>> &v) { for (int i = 0; i < v.size(); ++i) { for (int j = 0; j < v[0].size(); ++j) { if (j != 0) { std::cout << " "; } std::cout << std::setw(13) << std::left << v[i][j]; } std::cout << "\n";}}

template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }

template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }

template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

template<typename T> T &chmin(T &a, const T &b) { return a = std::min(a, b); }

template<typename T> T &chmax(T &a, const T &b) { return a = std::max(a, b); }

template<class T> inline std::vector<T> unique(std::vector<T> v) { sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end()); return v; }

// 初項s, 交差dのn個の数列の和

long long sum_of_arithmetic_progression(long long s, long long d, long long n) { return n * (2 * s + (n - 1) * d) / 2; }



const int INF = 1 << 30;

const double EPS = 1e-9;

const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";

const std::vector<int> dy4 = {0, -1, 0, 1}, dx4 = {1, 0, -1, 0};

const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };



using namespace std;



template <typename T> class SegmentTree {

    const int array_size;        // もとの配列のサイズ

    int n;

    std::vector<T> data;

    std::function<T (T,T)> op;

    T unit;



public:

    enum Mode {

        RangeMinimumQuery,

        RangeMaximumQuery,

        RangeSummationQuery,

    };



    SegmentTree(int array_size, Mode mode) : array_size(array_size) {

        if (mode == RangeMinimumQuery) {

            unit = INT_MAX;

            op = [](T a, T b) { return std::min(a, b); };

        }

        else if (mode == RangeMaximumQuery) {

            unit = 0;

            op = [](T a, T b) { return std::max(a, b); };

        }

        else if (mode == RangeSummationQuery) {

            unit = 0;

            op = [](T a, T b) { return a + b; };

        }

        else {

            assert(false);

        }



        n = 1;

        while (n < array_size) { n *= 2; }   // _n以上の最小の2冪

        data.resize(2 * n - 1, unit);

    }



    template <typename F> SegmentTree(int array_size, T unit, F op) : array_size(array_size), unit(unit), op(op) {

        while (n < array_size) { n *= 2; }   // _n以上の最小の2冪

        data.resize(2 * n - 1, unit);

    }



    T access(int idx) {

        return data[idx + n - 1];

    }



    // array[idx] = x

    // O(log N)

    void update(int idx, T x) {

        assert(0 <= idx and idx < array_size);

        idx += n - 1;   // 木での対象のインデックス

        data[idx] = x;

        while (idx > 0) {

            idx = (idx - 1) / 2;                                    // 親のインデックス

            data[idx] = op(data[idx * 2 + 1], data[idx * 2 + 2]);   // 左の子と右の子

        }

    }



    // op(array[left, right))

    // O(log N)

    T query(int left, int right) {

        assert(0 <= left and left < right and right <= array_size);

        return query(left, right, 0, 0, n);

    }



private:

    // [a, b)の目的値をノードk（区間[l, r]）から検索

    T query(int a, int b, int k, int l, int r) {

        assert(a < b && l < r);

        // 範囲外

        if (r <= a || b <= l) {

            return unit;

        }

        // 完全に含む

        if (a <= l && r <= b) {

            return this->data[k];

        }

            // 一部含む

        else {

            T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);    // 左の子

            T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);    // 右の子

            return op(vl, vr);

        }

    }

};





int main() {

    cin.tie(0);

	ios::sync_with_stdio(false);



	int N;

	cin >> N;

	V<int> H(N), A(N);

	FOR(i, 0, N) {

	    cin >> H[i];

	}

    FOR(i, 0, N) {

        cin >> A[i];

    }



    SegmentTree<LL> st(2 * 100000 + 100, SegmentTree<LL>::RangeMaximumQuery);

	FOR(i, 0, N) {

	    int h = H[i];

	    int a = A[i];

	    LL v = st.query(0, h) + a;

	    st.update(h, max(st.access(h), v));

	}



	print(st.query(0, 2 * 100000 + 100));



	return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)

#define RFOR(i,a) for(int i=(a); i >= 0; --i)

#define FOE(i,a) for(auto i : a)

#define ALL(c) (c).begin(), (c).end()

#define RALL(c) (c).rbegin(), (c).rend()

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define SUM(x) std::accumulate(ALL(x), 0LL)

#define MIN(v) *std::min_element(v.begin(), v.end())

#define MAX(v) *std::max_element(v.begin(), v.end())

#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())

#define BIT_ON(bit, i) (((bit >> i) & 1) > 0)



typedef long long LL;

template<typename T> std::vector<T> make_v(size_t a){return std::vector<T>(a);}

template<typename T,typename... Ts> auto make_v(size_t a, Ts... ts){ return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));}    // C++14

template<typename T,typename V> typename std::enable_if<std::is_class<T>::value==0>::type fill_v(T &t,const V &v){t=v;}

template<typename T,typename V> typename std::enable_if<std::is_class<T>::value!=0>::type fill_v(T &t,const V &v){for(auto &e:t) fill_v(e,v);}

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }

template<class T> inline void print(T x) { std::cout << x << std::endl; }

template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }

template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }

template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }

template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

template<typename T> T &chmin(T &a, const T &b) { return a = std::min(a, b); }

template<typename T> T &chmax(T &a, const T &b) { return a = std::max(a, b); }



template<class T> inline std::vector<T> unique(std::vector<T> v) {

    sort(v.begin(), v.end());

    v.erase(unique(v.begin(), v.end()), v.end());

    return v;

}

// 初項s, 交差dのn個の数列の和

long long sum_of_arithmetic_progression(long long s, long long d, long long n) {

    return n * (2 * s + (n - 1) * d) / 2;

}



const int INF = 1 << 30;

const double EPS = 1e-9;

const long double PI = acos(-1.0);

const std::vector<int> dy2 = {0, 1}, dx2 = {1, 0};  // 右，下

const std::vector<int> dy4 = {0, -1, 0, 1}, dx4 = {1, 0, -1, 0};    // 右，上，左，下

const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };





using namespace std;





template <typename T> class SegmentTree {

    const int array_size;        // もとの配列のサイズ

    int n;

    std::vector<T> data;

    std::function<T (T,T)> op;

    T unit;



public:

    enum Mode {

        RangeMinimumQuery,

        RangeMaximumQuery,

        RangeSummationQuery,

    };



    SegmentTree(int array_size, Mode mode) : array_size(array_size) {

        if (mode == RangeMinimumQuery) {

            unit = INT_MAX;

            op = [](T a, T b) { return std::min(a, b); };

        }

        else if (mode == RangeMaximumQuery) {

            unit = 0;

            op = [](T a, T b) { return std::max(a, b); };

        }

        else if (mode == RangeSummationQuery) {

            unit = 0;

            op = [](T a, T b) { return a + b; };

        }

        else {

            assert(false);

        }



        n = 1;

        while (n < array_size) { n *= 2; }   // _n以上の最小の2冪

        data.resize(2 * n - 1, unit);

    }



    template <typename F> SegmentTree(int array_size, T unit, F op) : array_size(array_size), unit(unit), op(op) {

        while (n < array_size) { n *= 2; }   // _n以上の最小の2冪

        data.resize(2 * n - 1, unit);

    }



    T access(int idx) {

        return data[idx + n - 1];

    }



    // array[idx] = x

    // O(log N)

    void update(int idx, T x) {

        assert(0 <= idx and idx < array_size);

        idx += n - 1;   // 木での対象のインデックス

        data[idx] = x;

        while (idx > 0) {

            idx = (idx - 1) / 2;                                    // 親のインデックス

            data[idx] = op(data[idx * 2 + 1], data[idx * 2 + 2]);   // 左の子と右の子

        }

    }



    // op(array[left, right))

    // O(log N)

    T query(int left, int right) {

        assert(0 <= left and left < right and right <= array_size);

        return query(left, right, 0, 0, n);

    }



private:

    // [a, b)の目的値をノードk（区間[l, r]）から検索

    T query(int a, int b, int k, int l, int r) {

        assert(a < b && l < r);

        // 範囲外

        if (r <= a || b <= l) {

            return unit;

        }

        // 完全に含む

        if (a <= l && r <= b) {

            return this->data[k];

        }

            // 一部含む

        else {

            T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);    // 左の子

            T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);    // 右の子

            return op(vl, vr);

        }

    }

};





int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    int N;

    cin >> N;

    auto H = make_v<int>(N);

    auto A = make_v<int>(N);

    FOR(i, 0, N) {

        cin >> H[i];

    }

    FOR(i, 0, N) {

        cin >> A[i];

    }



    SegmentTree<LL> st(N + 100, SegmentTree<LL>::RangeMaximumQuery);



    FOR(i, 0, N) {

        int h = H[i];

        int a = A[i];



        LL maxi = st.query(0, h);

        st.update(h, maxi + a);

    }

    print(st.query(0, N + 10));



    return 0;

}

// Fastest known solution for this problem: