using System;
using System.Collections.Generic;
using System.IO;

namespace Contest
{
    class SegTree<T>
    {
        private readonly T[] Array;
        private readonly Comparison<T> Compare;
        private readonly int N;
        private readonly T Max;
        public SegTree(int size, T max) : this(size, Comparer<T>.Default, max) { }
        public SegTree(int size, IComparer<T> comparer, T max) : this(size, comparer.Compare, max) { }
        public SegTree(int size, Comparison<T> comparison, T max)
        {
            Max = max;
            N = 1;
            while (N < size)
            {
                N *= 2;
            }
            Compare = comparison;
            Array = new T[2 * N];
            for (int i = 1; i < 2 * N; i++)
            {
                Array[i] = max;
            }
        }

        new public T this[int i]
        {
            get { return Array[i + N]; }
            set { Update(value, i); }
        }


        private T Min(T x, T y)
        {
            return Compare(x, y) < 0 ? x : y;
        }

        public void Update(T item, int index)
        {
            index += N;
            Array[index] = item;
            while (index > 1)
            {
                index /= 2;
                Array[index] = Min(Array[index * 2], Array[index * 2 + 1]);
            }
        }

        private T Q(int left, int right, int k, int l, int r)
        {
            if (left <= l && r <= right)
            {
                return Array[k];
            }
            if (r <= left || right <= l)
            {
                return Max;
            }
            return Min(Q(left, right, k * 2, l, (l + r) / 2), Q(left, right, k * 2 + 1, (l + r) / 2, r));
        }

        public T Query(int left, int right)
        {
            return Q(left, right, 1, 0, N);
        }

    }
    class Program
    {
        private Scanner sc;
        private int N;
        private int[] H;
        private long[] A;
        public void Solve()
        {
            sc = new Scanner();
            N = sc.NextInt();
            H = sc.IntArray();
            A = sc.LongArray();

            var st = new SegTree<long>(N + 1, (a, b) => -a.CompareTo(b), long.MinValue);
            st[0] = 0;
            for (int i = 0; i < N; i++)
            {

                st[H[i]] = st.Query(0, H[i]) + A[i];
            }
            Console.WriteLine(st.Query(0, N + 1));
        }


        static void Main() => new Program().Solve();
    }
}

class Scanner
{
    public Scanner()
    {
        _stream = new StreamReader(Console.OpenStandardInput());
        _pos = 0;
        _line = new string[0];
        _separator = ' ';
    }
    private readonly char _separator;
    private readonly StreamReader _stream;
    private int _pos;
    private string[] _line;
    #region get a element
    public string Next()
    {
        if (_pos >= _line.Length)
        {
            _line = _stream.ReadLine().Split(_separator);
            _pos = 0;
        }
        return _line[_pos++];
    }
    public int NextInt()
    {
        return int.Parse(Next());
    }
    public long NextLong()
    {
        return long.Parse(Next());
    }
    public double NextDouble()
    {
        return double.Parse(Next());
    }
    #endregion
    #region convert array
    private int[] ToIntArray(string[] array)
    {
        var result = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = int.Parse(array[i]);
        }

        return result;
    }
    private long[] ToLongArray(string[] array)
    {
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = long.Parse(array[i]);
        }

        return result;
    }
    private double[] ToDoubleArray(string[] array)
    {
        var result = new double[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = double.Parse(array[i]);
        }

        return result;
    }
    #endregion
    #region get array
    public string[] Array()
    {
        if (_pos >= _line.Length)
            _line = _stream.ReadLine().Split(_separator);
        _pos = _line.Length;
        return _line;
    }
    public int[] IntArray()
    {
        return ToIntArray(Array());
    }
    public long[] LongArray()
    {
        return ToLongArray(Array());
    }
    public double[] DoubleArray()
    {
        return ToDoubleArray(Array());
    }
    #endregion
}

Measured memory_bytes: 45392