# @EXPECTED_RESULTS@: ACCEPTED, TIME_LIMIT_EXCEEDED
import itertools

n = int(input())
fi = list(map(int, input().split()))
ti = list(map(int, input().split()))

M = 2000000

ds = []
last_floor = 0
for i in range(n - 1):
    if last_floor <= fi[i] <= fi[i + 1] or last_floor >= fi[i] >= fi[i + 1]:
        ds.append(ti[i])
    elif last_floor <= fi[i] and fi[i] >= fi[i + 1]:
        ds.append(-(M - 2 * fi[i]) + ti[i])
    elif last_floor >= fi[i] and fi[i] <= fi[i + 1]:
        ds.append((M - 2 * fi[i]) + ti[i])
    else:
        assert False

    last_floor = fi[i]
ds += [-x for x in ds]
ds = [x % M for x in ds]
ds = sorted(list(set(ds)))
if not ds:
    ds = [0]
# print(ds)

# be at pos=M-600k at t=600k+50k
# start at 0 at t-pos = (M-600k)-(600k+50k) = M-1.25M = -750k
#

# lf  f
# ---->
# ----------------|
#     <-----------|


# Four lifts: ABCD
# Lift A goes at t=0
# lift BCD variable
# 6 deltas:
# 0   1   2   3   4   5
# AB, AC, AD, BC, BD, CD
# A spanning tree of 3 of the deltas must equal a ti difference.

# edges = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]

# Enumerate spanning trees: all but the 4 triangles.
# trees = []
# for e1, e2, e3 in itertools.combinations(range(6), 3):
#     order = [0]
#     for u, v in (edges[e1], edges[e2], edges[e3]):
#         ok = True
#         if u not in order or v - 1 not in order or v in order:
#             ok = False
#             break
#         order.append(v)
#     if not ok:
#         continue

#     print(order)
#     assert order == [0, 1, 2, 3]
#     trees.append([edges[e1], edges[e2], edges[e3]])
# # print(trees)

# # (6 choose 3) - 4 = 16
# assert len(trees) == 16

trees = [
    [(0, 1), (0, 2), (0, 3)],
    [(0, 1), (0, 2), (1, 3)],
    [(0, 1), (1, 2), (1, 3)],
    [(0, 1), (1, 2), (2, 3)],
]

# For each tree, try all possible assignments of deltas from ti for the three edges.

# 16*35*35*35 options = 686000
# total complexity: (16*35*35*35)*35*4 = 96 million
best_time = 10**18
best_sol = ""
best_tree = None
best_ts = None
for tree in trees:
    for d1 in ds:
        for d2 in ds:
            for d3 in ds:
                dds = [d1, d2, d3]
                ts = [0, None, None, None]
                done = 0
                for u, v in tree:
                    ts[v] = ts[u] + dds[done]
                    done += 1

                assert None not in ts
                # print("new", tree, ds, ts)
                time = 0
                floor = 0
                sol = ""
                for f, t in zip(fi, ti):
                    # Find the first elevator going from `floor` to `f`.
                    if f > floor:
                        target_floor = floor
                    else:
                        target_floor = M - floor
                    first_at_target = 10**18
                    # Want to be at `target_floor` at `time`
                    best_i = 0
                    for i in range(4):
                        # start with delay of ts[i].
                        at_target = (target_floor + ts[i] - time) % M
                        # print(
                        #     f"target floor {target_floor} time {time} elevator {i} ts {ts[i]} wait {at_target}"
                        # )
                        if at_target < first_at_target:
                            best_i = i
                        first_at_target = min(first_at_target, at_target)
                    sol += "ABCD"[best_i]
                    time += first_at_target
                    time += abs(floor - f)
                    time += t
                    # print(
                    #     f"process {f}, {t} => target {target_floor} wait {first_at_target} total time {time}"
                    # )
                    floor = f
                # print("final time", time, "\n")
                if time < best_time:
                    best_sol = sol
                    best_tree = tree
                    best_ts = ts
                best_time = min(best_time, time)
print(best_time)
# print(best_sol)
# print(best_tree)
# print(best_ts)