import Data.List
import Data.Array  --変数衝突
import Data.Array.Unboxed
import Data.Array.MArray
import Data.Array.ST
import qualified Data.Vector.Unboxed as V (last,(!),fromList,Vector)
import Control.Monad
import Control.Monad.ST

type DP s = STUArray s Int Int

{-
セグ木について
sup2によりnを２の冪にする
配列をdp[1]~[n] 変数はi'
セグ木をsegT[1]~[2*n-1] 変数はi
添え字iに対して、親ノードはi`div`2、子ノードは2*i,2*i+1
高さは (floor logBase 2 (fromIntegral i))+1
関数名についている1は葉を表している
-}
-- n+n/2+n/4+...<=2*n-1だが、子ノードの定義の仕方により2*n-1を超えることがある。

--nを超える最小の２の冪
sup2 :: Int -> Int
sup2 n = 2^(ceiling $ logBase 2 (fromIntegral n :: Double) :: Int)

newSegT :: MArray a e m => (Int,Int) -> e -> m (a Int e)
newSegT (1,n) e = newArray (1,2*n-1) e

read1SegT :: MArray a e m => a Int e -> Int -> Int -> m e
read1SegT dparr i' i = readArray dparr (i'+i-1)

write1SegT :: MArray a e m => a Int e -> Int -> Int -> e -> m ()
write1SegT dparr i' i e = writeArray dparr (i'+i-1) e

--logN
readPSegT :: DP s -> (Int,Int) -> Int -> Int -> Int -> Int -> ST s Int
readPSegT dparr (l,r) n i' i max0
  | 2*n-1 < i = return max0 ---Error??-----
  | otherwise = do
    let mid = (l+r)`div`2
    a <- readArray dparr i
    if mid < i'
      then readPSegT dparr (mid+1,r) n i' (2*i+1) (max a max0)
      else readPSegT dparr (l,mid) n i' (2*i) (max a max0)

--セグ木の更新,O((logN)^2)
--(left,right)の範囲で更新
modifyRSegT :: DP s -> (Int,Int) -> (Int,Int) -> Int -> Int -> Int -> ST s ()
modifyRSegT dparr (left,right) (l,r) a n i
  | right < left = return ()
  | 2*n-1 < i   = error $ "modifyRSegT Error : i = " ++ (show i) ++ (show ((left,right), (l,r), a)) ---Error??
  | left == l && right >= r = do
   a' <- readArray dparr i
   writeArray dparr i (max a' a)
   traceShowM ((l,r),i,a,a',3)
  | otherwise  = do
   let mid = (l+r)`div`2
   if mid < left
     then modifyRSegT dparr (left,right) (mid+1,r) a n (2*i+1)
     else modifyRSegT dparr (left,right) (l,mid) a n (2*i)

dp_i :: DP s -> Int -> [Int] -> [Int] -> ST s ()
dp_i dparr n [] [] = return ()
dp_i dparr n (h:hs) (a:as) = do
  nowa <- readPSegT dparr (1,n) n h 1 0
  modifyRSegT dparr (h,n) (1,n) (nowa+a) n 1
  dp_i dparr n hs as

solve :: Int -> [Int] -> [Int] -> ST s Int
solve n hs as = do
  dparr <- newSegT (1,n) 0
  dp_i dparr n hs as
  readPSegT dparr (1,n) n n 1 0

main :: IO ()
main = do
 n  <- read <$> getLine
 hs <- map read.words <$> getLine
 as <- map read.words <$> getLine
 putStrLn $ show $ runST $ solve (sup2 n) hs as
