package main

import (
	"fmt"
	"io"
	"os"
)

var (
	tree []int64
	lazy []int64
	pref []int64
)

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func build(node, l, r int) {
	if l == r {
		tree[node] = pref[l]
		return
	}
	mid := (l + r) / 2
	build(2*node, l, mid)
	build(2*node+1, mid+1, r)
	tree[node] = min(tree[2*node], tree[2*node+1])
}

func push(node int) {
	if lazy[node] != 0 {
		tree[2*node] += lazy[node]
		lazy[2*node] += lazy[node]
		tree[2*node+1] += lazy[node]
		lazy[2*node+1] += lazy[node]
		lazy[node] = 0
	}
}

func update(node, l, r, ql, qr int, val int64) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		tree[node] += val
		lazy[node] += val
		return
	}
	push(node)
	mid := (l + r) / 2
	update(2*node, l, mid, ql, qr, val)
	update(2*node+1, mid+1, r, ql, qr, val)
	tree[node] = min(tree[2*node], tree[2*node+1])
}

func main() {
	buffer, _ := io.ReadAll(os.Stdin)
	var cursor int

	next := func() int64 {
		for cursor < len(buffer) && buffer[cursor] <= ' ' {
			cursor++
		}
		if cursor >= len(buffer) {
			return 0
		}
		res := int64(0)
		for cursor < len(buffer) && buffer[cursor] > ' ' {
			res = res*10 + int64(buffer[cursor]-'0')
			cursor++
		}
		return res
	}

	n := int(next())
	if n == 0 {
		return
	}

	p := make([]int, n+1)
	posOf := make([]int, n+1)
	for i := 1; i <= n; i++ {
		p[i] = int(next())
		posOf[p[i]] = i
	}

	a := make([]int64, n+1)
	pref = make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = next()
		pref[i] = pref[i-1] + a[i]
	}

	tree = make([]int64, 4*n)
	lazy = make([]int64, 4*n)

	build(1, 1, n-1)

	ans := tree[1]

	for V := 1; V <= n; V++ {
		pos := posOf[V]
		if 1 <= pos-1 {
			update(1, 1, n-1, 1, pos-1, a[pos])
		}
		if pos <= n-1 {
			update(1, 1, n-1, pos, n-1, -a[pos])
		}
		if tree[1] < ans {
			ans = tree[1]
		}
	}

	fmt.Println(ans)
}