/* <ik:include(base.hpp)> */
/* subset of bits/stdc++.h */
#include<algorithm>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<vector>

using namespace std;

using LL = long long;
using ULL = unsigned long long;
#define int LL
#define times(n, i)      uptil(0, n, i)
#define rtimes(n, i)     downto((n) - 1, 0, i)
#define upto(f, t, i)    for(auto i##0_to = (t), i = decltype(t)(f); i <= i##0_to; i++)
#define uptil(f, t, i)   for(auto i##0_to = (t), i = decltype(t)(f); i <  i##0_to; i++)
#define downto(f, t, i)  for(auto i##0_to = decltype(f)(t), i = (f); i >= i##0_to; i--)
#define downtil(f, t, i) for(auto i##0_to = decltype(f)(t), i = (f); i >  i##0_to; i--)
#define iter(v) begin(v), end(v)
#define citer(v) cbegin(v), cend(v)
#if defined(EBUG) && !defined(ONLINE_JUDGE)
  #define debug true
  #define _GLIBCXX_DEBUG
  #define _LIBCPP_DEBUG 2
  #define _LIBCPP_DEBUG2 2
  #define ln << endl
  #define dd(x) cerr << #x << " = " << (x) << ", "
  #define ddd(x) cerr << #x << " = " << (x) ln
#else
  #define debug false
  #define ln << '\n'
  #define dd(x) cerr
  #define ddd(x) cerr
#endif
#define tb << '\t'
#define sp << ' '
#define db dd
#define dbg ddd
#if __cplusplus >= 201703L
  #if debug
    #define PARABLE execution::par_unseq,
  #else
    #define PARABLE execution::seq,
  #endif
#else
  #define PARABLE /* none */
#endif
#define CS const
#define IL inline
#define RT return
#define TL template
#define lambda [&]
#define foldl accumulate
#define scanl accumulate
typedef struct unit{}unit;

TL<class T> void amax(T&v,const T&a){v=max(v,a);}
TL<class T> void amin(T&v,const T&a){v=min(v,a);}

namespace kpl {
  template<class V, class W>
  static inline void append(V& v, const W& w) { copy(PARABLE citer(w), back_inserter(v)); }

  template<class V>
  static inline auto flatten(const V& xss, unsigned reserve_size = 0) {
    vector<decltype(*begin(*begin(xss)))> ret;
    ret.reserve(reserve_size);
    for(const auto& xs : xss) append(ret, xs);
    ret.shrink_to_fit();
    return move(ret);
  }

  template<class I>
  static inline bool is_in(I x, I l, I r) { /* Of course half-open interval [l,r) is used */
    return l <= x && x < r;
  }
}
/* <ik:include(mod.hpp)> */
#ifndef MOD
#ifdef MOD9
#define MOD 1000000009
#elif defined MOD998244353
#define MOD 998244353
#else
#define MOD 1000000007
#endif
#endif
/* <ik:include(power.hpp)> */
TL<class T> T power(T x,ULL n){T rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT rt;}
/* </ik:include(power.hpp)> */
IL int modulo(int a,int m){a%=m;RT a>=0?a:a+m;}
TL<ULL mod=MOD>class MInt{
  /*
    int with modulo.
    `mod` must be a prime for `log`.
    `mod` must be coprime to `val` for `inv` and to `m.val` for `operator/` and `operator/=`.
  */
  /*! https://ei1333.github.io/luzhiled/snippets/other/mod-int.html */
public:
  int val;
  MInt():val(0){}
  explicit MInt(int v):val(modulo(v,mod)){}
  MInt&operator+=(CS MInt&m){val+=m.val;if(val>=mod)val-=mod;RT*this;}
  MInt&operator-=(CS MInt&m){val-=m.val;if(val<0)val+=mod;RT*this;}
  MInt&operator*=(CS MInt&m){val=val*m.val%mod;RT*this;}
  MInt&operator/=(CS MInt&m){val=val*m.inv().val%mod;RT*this;}
  MInt operator+(CS MInt&m)CS{RT MInt(*this)+=m;}
  MInt operator-(CS MInt&m)CS{RT MInt(*this)-=m;}
  MInt operator*(CS MInt&m)CS{RT MInt(*this)*=m;}
  MInt operator/(CS MInt&m)CS{RT MInt(*this)/=m;}
  MInt operator-()CS{MInt m;m.val=val?mod-val:0;RT m;}
  bool operator==(CS MInt&m)CS{RT val==m.val;}
  bool operator!=(CS MInt&m)CS{RT val!=m.val;}
  //MInt pow(int n)CS{MInt x(*this),rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT rt;}
  MInt pow(int n)CS{RT power(*this,n);}
  MInt inv()CS{int a=val,b=mod,x=1,y=0,t;while(b){t=a/b;swap(b,a-=t*b);swap(y,x-=t*y);}RT(MInt)x;}
  friend ostream&operator<<(ostream&o,CS MInt<mod>&m){RT o<<m.val;}
  friend istream&operator>>(istream&i,MInt<mod>&m){int v;i>>v;m=MInt<mod>(v);RT i;}
};
using mint=MInt<>;
#pragma rab:gsub \b(\d+)mi\b mint(\1)
/* </ik:include(mod.hpp)> */
/* <ik:include(vector_usings.hpp)> */
TL<class T> using vec = vector<T>;
TL<class T> using vvec = vec<vec<T>>;
#define VUSE(v,t)using P##v=pair<t,t>;using V##v=vec<t>;using W##v=vvec<t>
VUSE(I,int);VUSE(M,mint);VUSE(PI,PI);VUSE(PM,PM);
/* </ik:include(vector_usings.hpp)> */
/* <ik:include(debug.hpp)> */
TL<class T>
IL istream&operator>>(istream&s,vec<T>&v){for(auto&&p:v)s>>p;RT s;}
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS pair<T,S>&p){RT s<<"("<<p.first<<","<<p.second<<")";}
TL<class T>
IL ostream&operator<<(ostream&,CS vec<T>&);
TL<class T,class S>
IL ostream&operator<<(ostream&,CS map<T,S>&);
#define DEFINE_ITER_OUTPUT(s,x,sep){int i=0;for(CS auto&x##0_elem:x){if(i++)s<<sep;s<<x##0_elem;}RT s;}
TL<class T>
IL ostream&operator<<(ostream&s,CS vec<T>&v)DEFINE_ITER_OUTPUT(s,v,' ')
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS map<T,S>&m)DEFINE_ITER_OUTPUT(s,m,' ')
TL<class T>
IL ostream&operator<<(ostream&s,CS vec<vec<T>>&w)DEFINE_ITER_OUTPUT(s,w,'\n')
TL<class T,class S>
IL ostream&operator<<(ostream&s,CS vec<map<T,S>>&v)DEFINE_ITER_OUTPUT(s,v,'\n')
/* </ik:include(debug.hpp)> */

void solve();

signed main() {
  if(debug) {
    cerr << "mod = " << MOD ln;
  } else {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
  cout << fixed << setprecision(20);
  cerr << fixed << setprecision(20);

  solve();

  return 0;
}
/* </ik:include(base.hpp)> */
/* <ik:include(segtree.hpp)> */
template<class V>
class SegTree{
  /*
    Segment tree.
    V: 結合法則、単位元
    eg.
      RMQ: SegTree<int>(N, LLONG_MIN, lambda(int a, int b){ return max(a, b); })
      RmQ: SegTree<int>(N, LLONG_MAX, lambda(int a, int b){ return min(a, b); })
  */
  /*!
    https://ei1333.github.io/luzhiled/snippets/structure/segment-tree.html
    https://codeforces.com/blog/entry/18051
  */
  int n;
  vec<V> vs;
  V id_elem;
  using Fn = function<V(V, V)>;
  Fn fn;
public:

  SegTree(int n0, const V& id_elem, Fn fn): id_elem(id_elem), fn(fn) {
    for(n = 1; n < n0; n *= 2);
    vs.resize(2 * n, id_elem);
  }

  const V& operator[](int i) const { return vs[n + i]; }
  void set(int i, const V& v) {
    i += n;
    for(vs[i] = v; i > 1; i /= 2) { vs[i / 2] = fn(vs[i], vs[i ^ 1]); }
  }

  void set_before_rebuild(int i, const V& v) { vs[n + i] = v; }
  void rebuild() {
    downtil(n - 1, 0, i) { vs[i] = fn(vs[i / 2], vs[i / 2 | 1]); }
  }

  V query(int l, int r) { /* 半開区間 */
    V vl = id_elem, vr = id_elem;
    for(l += n, r += n; l < r; l /= 2, r /= 2) {
      if(l & 1) vl = fn(vl, vs[l++]);
      if(r & 1) vr = fn(vs[--r], vr);
    }
    return fn(vl, vr);
  }
};
/* </ik:include(segtree.hpp)> */
constexpr int INF = 1LL << 60;

void solve(){
// NN(H)N(A)
/* <foxy.memo-area> */
int N;cin>>N;VI H(N);times(N,Ri_0){cin>>H[Ri_0];}VI A(N);times(N,Ri_0){cin>>A[
Ri_0];}
/* </foxy.memo-area> */

  SegTree<int> sg(N+1, LLONG_MIN, lambda(int a, int b){ return max(a, b); });
  sg.set(0, 0);
  times(N, i) {
    sg.set(H[i], sg.query(0, H[i]) + A[i]);
  }
  cout << sg.query(0, N+1) ln;
}


Measured memory_bytes: 7424