package main
 
import (
	"bufio"
	"fmt"
	"os"
)
 
const INF = int64(1e18)
 
var (
	tree []int64
	lazy []int64
)
 
func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}
 
func build(node, l, r int) {
	lazy[node] = 0
	if l == r {
		tree[node] = -INF
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid)
	build(node*2+1, mid+1, r)
	tree[node] = max(tree[node*2], tree[node*2+1])
}
 
func pushDown(node int) {
	if lazy[node] != 0 {
		tree[node*2] += lazy[node]
		lazy[node*2] += lazy[node]
		tree[node*2+1] += lazy[node]
		lazy[node*2+1] += lazy[node]
		lazy[node] = 0
	}
}
 
func updateSet(node, l, r, idx int, val int64) {
	if l == r {
		tree[node] = val
		lazy[node] = 0
		return
	}
	pushDown(node)
	mid := (l + r) / 2
	if idx <= mid {
		updateSet(node*2, l, mid, idx, val)
	} else {
		updateSet(node*2+1, mid+1, r, idx, val)
	}
	tree[node] = max(tree[node*2], tree[node*2+1])
}
 
func updateAdd(node, l, r, ql, qr int, val int64) {
	if ql <= l && r <= qr {
		tree[node] += val
		lazy[node] += val
		return
	}
	pushDown(node)
	mid := (l + r) / 2
	if ql <= mid {
		updateAdd(node*2, l, mid, ql, qr, val)
	}
	if qr > mid {
		updateAdd(node*2+1, mid+1, r, ql, qr, val)
	}
	tree[node] = max(tree[node*2], tree[node*2+1])
}
 
func queryMax(node, l, r, ql, qr int) int64 {
	if ql <= l && r <= qr {
		return tree[node]
	}
	pushDown(node)
	mid := (l + r) / 2
	res := -INF
	if ql <= mid {
		res = max(res, queryMax(node*2, l, mid, ql, qr))
	}
	if qr > mid {
		res = max(res, queryMax(node*2+1, mid+1, r, ql, qr))
	}
	return res
}
 
func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)
 
	h := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &h[i])
	}
 
	b := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &b[i])
	}
 
	tree = make([]int64, 4*(n+1))
	lazy = make([]int64, 4*(n+1))
 
	build(1, 0, n)
 
	dp := make([]int64, n+1)
	dp[0] = 0
 
	stack := make([]int, 0)
 
	for i := 1; i <= n; i++ {
		updateSet(1, 0, n, i-1, dp[i-1])
 
		for len(stack) > 0 && h[stack[len(stack)-1]] > h[i] {
			k := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			prev := 0
			if len(stack) > 0 {
				prev = stack[len(stack)-1]
			}
			updateAdd(1, 0, n, prev, k-1, -b[k])
		}
 
		prev := 0
		if len(stack) > 0 {
			prev = stack[len(stack)-1]
		}
		updateAdd(1, 0, n, prev, i-1, b[i])
 
		stack = append(stack, i)
		dp[i] = queryMax(1, 0, n, 0, i-1)
	}
 
	fmt.Println(dp[n])
}