#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll mod = 1e9 + 7;

int a[1001], b[1001];
int psuma[1001];
pii dp[1001][2][10501];

int range_sum(int l, int r) { return l <= r ? psuma[r] - psuma[l - 1] : 0; }

pii ns(int bro, pii cur, int d) {
    if (cur.second + d <= a[cur.first]) return {cur.first, cur.second + d};
    d -= (a[cur.first] - cur.second), cur = {cur.first, a[cur.first]};
    if (cur.first + 1 == bro) return cur;
    int lo = cur.first, hi = bro;

    while (lo + 1 < hi) {
        int mid = (lo + hi) >> 1;
        if (range_sum(cur.first + 1, mid) >= d) hi = mid;
        else lo = mid;
    }
    cur = {lo, a[lo]}, d -= range_sum(cur.first + 1, lo);
    if (d && lo + 1 < bro) return {lo + 1, min(d, a[lo + 1])};
    else return cur;
}

void solve() {
    int n;
    cin >> n;
    for (int i = 0; i <= n; i++)
        for (int j = 0; j <= 10000; j++) dp[i][0][j] = dp[i][1][j] = {-1, -1};

    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    for (int i = 1; i <= n; i++) psuma[i] = psuma[i - 1] + a[i];

    dp[0][0][0] = {0, 0};
    for (int i = 0; i < n; i++) {
        for (int t = 0; t <= 10000; t++) {
            if (dp[i][0][t] != pii(-1, -1)) {
                dp[i + 1][1][t + b[i + 1]] = max(dp[i + 1][1][t + b[i + 1]], ns(i + 1, dp[i][0][t], b[i + 1]));
                // cout << i + 1 << " " << dp[i][0][t].first << " " << dp[i][0][t].second << " " << b[i + 1] << " : " << ns(i + 1, dp[i][0][t], b[i + 1]).first << " "
                // << ns(i + 1, dp[i][0][t], b[i + 1]).second << "\n";
            }
            if (dp[i][1][t] != pii(-1, -1)) {
                dp[i + 1][0][t] = max(dp[i + 1][0][t], dp[i][1][t]);
                dp[i + 1][1][t + b[i + 1]] = max(dp[i + 1][1][t + b[i + 1]], ns(i + 1, dp[i][1][t], b[i + 1]));
            }
        }
    }

    int ans = 1e9;
    for (int i = 0; i <= 10000; i++) {
        if (dp[n][0][i] != pii(-1, -1)) {
            ans = min(ans, i + a[dp[n][0][i].first] - dp[n][0][i].second + range_sum(dp[n][0][i].first + 1, n));
        }
        if (dp[n][1][i] != pii(-1, -1)) {
            ans = min(ans, i + a[dp[n][1][i].first] - dp[n][1][i].second + range_sum(dp[n][1][i].first + 1, n));
        }
    }
    cout << ans << "\n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int T = 1;
    // cin >> T;
    while (T--) solve();
    return 0;
}