/*****/

#define TRUE true
#define FALSE false

#include <bits/stdc++.h>

/**/
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
/**/

using namespace std;
using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<long long, long long>;
template <class T>
using vec = vector<T>;
template <class T>
using vec2 = vector<vector<T>>;
template <class T>
using vec3 = vector<vector<vector<T>>>;

constexpr int INF = numeric_limits<int>::max();
constexpr ll INFL = numeric_limits<ll>::max();
constexpr ll MOD = 1000000007; // 10^9+7

#ifdef TRUE

#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrep1(i, n) for (ll i = (n); i > 0; --i)
#define step(i, a, n) for (ll i = (a), i##_len = (a) + (n); i < i##_len; ++i)
#define rstep(i, a, n) for (ll i = (a) + (n)-1, i##_len = (a); i >= i##_len; --i)
#define range(i, a, b) for (ll i = (a), i##_len = (b); i < i##_len; ++i)
#define rrange(i, a, b) for (ll i = (b)-1, i##_len = (a); i >= i##_len; --i)

std::string strMulti(const int n, const std::string &t)
{
	std::string out = "";
	for (int i = 0; i < n; i++)
	{
		out += t;
	}
	return out;
}
std::string tab(const int n)
{
	return string(n, '\t');
}
std::string join(const vector<string> &v, const char *delim = 0)
{
	std::string s;
	if (!v.empty())
	{
		s += v[0];
		for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i)
		{
			if (delim)
				s += delim;
			s += v[i];
		}
	}
	return s;
}

string to_string(string &s) { return '"' + s + '"'; }
string to_string(char &c) { return string({'\'', c, '\''}); }
template <class T1, class T2>
string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <class Tuple, size_t... I>
string _to_string_tuple(Tuple &&t, std::index_sequence<I...>) { return "(" + join({to_string(std::get<I>(t))...}, ", ") + ")"; }
template <class... Args>
string to_string(tuple<Args...> t) { return _to_string_tuple(std::forward<tuple<Args...>>(t), std::make_index_sequence<std::tuple_size<std::decay_t<tuple<Args...>>>::value>{}); }
template <class T>
string to_string(vector<T> ar)
{
	vector<string> texts(ar.size());
	for (size_t i = 0; i < ar.size(); ++i)
	{
		texts[i] = to_string(ar[i]);
	}
	return "{" + join(texts, ", ") + "}";
}
template <class T>
string to_string(initializer_list<T> il)
{
	vector<string> texts(il.size());
	size_t i = 0;
	for (T v : il)
	{
		texts[i] = to_string(v);
		i++;
	}
	return "{" + join(texts, ", ") + "}";
}

void debug(string name);
void debugn(string name);
template <class T>
void debug(string name, T v);
template <class T>
void debugn(string name, T v);
template <class T>
void debug(string name, initializer_list<T> il);
template <class T>
void debugn(string name, initializer_list<T> il);
template <class... Args>
void debug(string name, Args... args);
template <class... Args>
void debugn(string name, Args... args);
void debugdo(function<void()> func);

#ifdef DEBUG_BUILD
#define debugvar(x) debugn(#x, (x))
#define debugvartab(x, t) debugn(tab(t) + #x, (x))
void debug(string name)
{
	std::cerr << name;
}
void debugn(string name) { std::cerr << name << '\n'; }
template <class T>
void debug(string name, T v) { std::cerr << name << " = " << to_string(v); }
template <class T>
void debugn(string name, T v) { std::cerr << name << " = " << to_string(v) << '\n'; }
template <class T>
void debug(string name, initializer_list<T> il) { std::cerr << name << " = " << to_string(il); }
template <class T>
void debugn(string name, initializer_list<T> il) { std::cerr << name << " = " << to_string(il) << '\n'; }
template <class... Args>
void debug(string name, Args... args) { std::cerr << name << " = " << to_string(tuple<Args...>(args...)); }
template <class... Args>
void debugn(string name, Args... args) { std::cerr << name << " = " << to_string(tuple<Args...>(args...)) << '\n'; }
void debugdo(function<void()> func) { func(); }
#else
#define debugvar(x)
#define debugvartab(x, t)
void debug(string name)
{
}
void debugln(string name) {}
template <class T>
void debug(string name, T v) {}
template <class T>
void debugn(string name, T v) {}
template <class T>
void debug(string name, initializer_list<T> il) {}
template <class T>
void debugn(string name, initializer_list<T> il) {}
template <class... Args>
void debug(string name, Args... args) {}
template <class... Args>
void debugn(string name, Args... args) {}
void debugdo(function<void()> func) {}
#endif

#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)

template <class T>
bool chmax(T &a, const T b)
{
	if (a < b)
	{
		a = b;
		return true;
	}
	return false;
}
template <class T>
bool chmin(T &a, const T b)
{
	if (a > b)
	{
		a = b;
		return true;
	}
	return false;
}
template <class T>
T divup(const T a, const T b)
{
	if (a % b == 0)
	{
		return a / b;
	}
	return a / b + 1;
}
template <class T>
bool cmp_2nd(pair<T, T> a, pair<T, T> b)
{
	if (a.second != b.second)
	{
		return a.second < b.second;
	}
	return a.first < b.first;
}
ll modpow(ll x, ll n, const ll &p)
{
	ll ret = 1;
	while (n > 0)
	{
		if (n & 1)
		{
			(ret *= x) %= p;
		}
		(x *= x) %= p;
		n >>= 1;
	}
	return ret;
}
template <class T>
T modinv(T a, const T &p)
{
	T b = p, u = 1, v = 0;
	while (b)
	{
		T t = a / b;
		a -= t * b;
		swap(a, b);
		u -= t * v;
		swap(u, v);
	}
	u %= p;
	if (u < 0)
	{
		u += p;
	}
	return u;
}
template <class T>
T math_P(T m, T n)
{
	T ret = 1;
	for (T i = m; i > m - n; i--)
	{
		ret *= i;
	}
	return ret;
}
template <class T>
T math_C(T m, T n)
{
	T ret = math_P(m, n);
	for (T i = 2; i <= n; i++)
	{
		ret /= i;
	}
	return ret;
}
ll extended_euclidean(ll u, ll v)
{
	ll r0 = u;
	ll r1 = v;
	ll s0 = 1;
	ll s1 = 0;
	ll t0 = 0;
	ll t1 = 1;
	while (r1 != 0)
	{
		ll q = r0 / r1;
		ll r = r0 - q * r1;
		ll s = s0 - q * s1;
		ll t = t0 - q * t1;
		r0 = r1;
		s0 = s1;
		t0 = t1;
		r1 = r;
		s1 = s;
		t1 = t;
	}
	if (t0 < 0)
	{
		return t0 + u;
	}
	else
	{
		return t0;
	}
}
ll math_C_mod(ll n, ll c, const ll &p)
{
	ll upe = 1;
	ll dow = 1;
	for (ll i = 1; i < c + 1; ++i)
	{
		upe = upe * n % p;
		dow = dow * i % p;
		n -= 1;
	}
	return (upe * extended_euclidean(p, dow)) % p;
}
template <class T>
T math_gcd(T a, T b)
{
	if (b == 0)
	{
		return a;
	}
	else
	{
		return math_gcd(b, a % b);
	}
}
template <class T>
T math_lcm(T a, T b) { return a / math_gcd(a, b) * b; }
template <class T>
T SumStep(T a, T n, T d) { return n * (2 * a + (n - 1) * d) / 2; }
template <class T>
T SumRange(T a, T b, T d) { return SumStep(a, (b - a) / d, d); }

#endif

/*****/

// 遅延評価セグメント木
// X : datの要素の型    M : lazyの要素の型
template <class X, class M>
class SegTreeLazyProportional
{
public:
	// 根/下の葉 から 上の葉 への更新
	using FX = function<X(X, X)>;
	// lazyの要素をdatに移すの更新
	using FA = function<X(X, M)>;
	// lazyをupdate()などで上書きする更新
	using FM = function<M(M, M)>;
	// 高さによる葉への影響
	using FP = function<M(M, int)>;

	// モノイド(集合X, 二項演算fx,fa,fm,fp 単位元ex,em)についてサイズnで構築
	SegTreeLazyProportional(int n_, FX fx_, FA fa_, FM fm_, FP fp_, X ex_, M em_)
		: n(), fx(fx_), fa(fa_), fm(fm_), fp(fp_), ex(ex_), em(em_), dat(n_ * 4, ex), lazy(n_ * 4, em)
	{
		int x = 1;
		while (n_ > x)
			x *= 2;
		n = x;
	}

	// i番目の要素をxにセット。build()で構築
	void set(int i, X x) { dat[i + n - 1] = x; }

	// まとめてセグ木を構築する。O(n)
	void build()
	{
		for (int k = n - 2; k >= 0; k--)
			dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
	}

	// [a,b)全てにfa(x)を作用させる。O(log(n))
	void update(int a, int b, M x) { update(a, b, x, 0, 0, n); }

	// [a,b)全てにfxを作用させた値を取得。O(log(n))
	X query(int a, int b) { return query_sub(a, b, 0, 0, n); }

private:
	int n;
	FX fx;
	FA fa;
	FM fm;
	FP fp;
	const X ex;
	const M em;
	vector<X> dat;
	vector<M> lazy;

	/* lazy eval */
	void eval(int k, int len)
	{
		if (lazy[k] == em)
			return; // 更新するものが無ければ終了
		if (k < n - 1)
		{ // 葉でなければ子に伝搬
			lazy[k * 2 + 1] = fm(lazy[k * 2 + 1], lazy[k]);
			lazy[k * 2 + 2] = fm(lazy[k * 2 + 2], lazy[k]);
		}
		// 自身を更新
		dat[k] = fa(dat[k], fp(lazy[k], len));
		lazy[k] = em;
	}

	void update(int a, int b, M x, int k, int l, int r)
	{
		eval(k, r - l);
		if (a <= l && r <= b)
		{ // 完全に内側の時
			lazy[k] = fm(lazy[k], x);
			eval(k, r - l);
		}
		else if (a < r && l < b)
		{												// 一部区間が被る時
			update(a, b, x, k * 2 + 1, l, (l + r) / 2); // 左の子
			update(a, b, x, k * 2 + 2, (l + r) / 2, r); // 右の子
			dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
		}
	}

	X query_sub(int a, int b, int k, int l, int r)
	{
		eval(k, r - l);
		if (r <= a || b <= l)
		{ // 完全に外側の時
			return ex;
		}
		else if (a <= l && r <= b)
		{ // 完全に内側の時
			return dat[k];
		}
		else
		{ // 一部区間が被る時
			X vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
			X vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
			return fx(vl, vr);
		}
	}
};

void Main()
{
	int N;
	cin >> N;

	using X = long long;
	using M = long long;
	auto fx = [](X x1, X x2) -> X { return max(x1, x2); };
	auto fa = [](X x, M m) -> X { return m; };
	auto fm = [](M m1, M m2) -> M { return max(m1, m2); };
	auto fp = [](M m, long long n) -> M { return m; };
	X ex = 0;
	M em = 0;
	SegTreeLazyProportional<X, M> rmq(N, fx, fa, fm, fp, ex, em);

	rmq.build();

	vec<pair<int, ll>> F(N);

	rep(i, N) cin >> F[i].first;
	rep(i, N) cin >> F[i].second;

	ll res = 0;
	rep(i, N)
	{
		ll A = rmq.query(0, F[i].first);

		if (rmq.query(F[i].first, F[i].first + 1) < A + F[i].second)
		{
			rmq.update(F[i].first, F[i].first + 1, A + F[i].second);
			res = max(res, A + F[i].second);
		}
	}

	cout << res << endl;
}

/*****/

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);

	std::cout << std::fixed << std::setprecision(10);

	Main();
	std::cerr << flush;
	std::cout << flush;

	return 0;
}


Measured memory_bytes: 18712