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])
}