#pragma GCC optimize("O3")

// #define DEBUG
// #define TESTRUN
// #define ANADI

#include<bits/stdc++.h>
using namespace std;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define losuj(a, b) uniform_int_distribution<long long>(a, b)(rng)

#define sz(s) (int)s.size()
#define all(s) s.begin(), s.end()
#define f first
#define s second
#define pb push_back

#define ii pair<int, int>
#define vi vector<int>
#define vii vector<ii>
#define vvi vector<vi>
#define vvii vector<vii>

#define ll long long

const int N = 1e5 + 7;
const int INF = 1e9 + 7;
const ll BIG_INF = 1e18;

#ifdef DEBUG
const int T = 1 << 6;
#else
const int T = 1 << 17; // 2**17 > 100k    
#endif

bool swapped = false;
int A[N];
int B[N];
int tab[N];

int n, k;

vector<int> wziete;

namespace case_odejmuj {
    namespace maxi {
        // potrzebuję maksa na przedziale - pozycji i wartości
        pair<int, int> tree[T + T];

        pair<int, int> ask(int pocz, int kon) {
            if (kon < pocz)
                return { -INF, INF };
            pocz += T;
            kon += T;
            pair<int, int> ret = max(tree[pocz], tree[kon]);
            while (pocz >> 1 != kon >> 1) {
                if (!(pocz & 1))
                    ret = max(ret, tree[pocz + 1]);
                if (kon & 1)
                    ret = max(ret, tree[kon - 1]);
                pocz >>= 1;
                kon >>= 1;
            }
            return ret;
        }

        void add(int poz, int val) {
            poz += T;
            tree[poz].f += val;

            poz >>= 1;

            while (poz) {
                tree[poz] = max(tree[poz + poz], tree[poz + poz + 1]);
                poz >>= 1;
            }
        }

        void clear() {
            for (int i = T; i < T + T; i++)
                tree[i] = make_pair(0, i - T);
            for (int i = T - 1; i >= 1; i--)
                tree[i] = max(tree[i + i], tree[i + i + 1]);
        }
    };

    namespace mini {
        // potrzebuję minimum na przedziale - pozycji i wartości
        // można to zrobić jednym kodem, ale nie chce mi się

        pair<ll, int> tree[T + T];
        ll lazy[T + T];

        // BEWARE COPY PASTE IS COMING!!!

        void push(int u) {
            tree[u].f += lazy[u];

            if (u < T) {
                lazy[u + u] += lazy[u];
                lazy[u + u + 1] += lazy[u];
            }

            lazy[u] = 0;
        }

        pair<ll, int> ask(int pocz, int kon, int u = 1, int lo = 0, int hi = T - 1) {
            push(u);
            if (kon < pocz or kon < lo or hi < pocz)
                return { BIG_INF, INF };
            if (pocz <= lo and hi <= kon)
                return tree[u];

            int mid = (lo + hi) >> 1;
            return min(
                ask(pocz, kon, u + u, lo, mid),
                ask(pocz, kon, u + u + 1, mid + 1, hi)
            );
        }

        void add(int pocz, int kon, ll val, int u = 1, int lo = 0, int hi = T - 1) {
            push(u);
            if (kon < pocz or kon < lo or hi < pocz)
                return;
            if (pocz <= lo and hi <= kon) {
                lazy[u] += val;
                push(u);
                return;
            }

            int mid = (lo + hi) / 2;
            add(pocz, kon, val, u + u, lo, mid);
            add(pocz, kon, val, u + u + 1, mid + 1, hi);
            tree[u] = min(tree[u + u], tree[u + u + 1]);
        }

        void clear() {
            for (int i = T; i < T + T; i++) {
                tree[i] = make_pair(0, i - T);
                lazy[i] = 0;
            }
            for (int i = T - 1; i >= 1; i--) {
                tree[i] = min(tree[i + i], tree[i + i + 1]);
                lazy[i] = 0;
            }
        }
    };


    bool moge(ll mid) {
        mini::clear();
        maxi::clear();

        int ile = 0;

        bool ok = true;
        for(int i = 1; i <= n; i++)
            wziete[i] = 0;
        
        ll last_wys = 0;
        for (int i = 1; i <= n; i++) {
            tab[i] = B[i] - A[i]; // o ile poprawię

            // dodawanie możliwości poprawy
            maxi::add(i, tab[i]);

            // dodawanie ograniczenia
            ll teraz = max(0LL, last_wys + B[i]);
            mini::add(i, i, teraz);
            last_wys = teraz;

            while (last_wys > mid) {
                if (ile == k) {
                    ok = false;
                    break;
                }

                // szukamy maxa;
                auto [val_max, poz_max] = maxi::ask(0, T - 1);
                if (val_max <= 0) {
                    ok = false;
                    break;
                }

                // czy ma on za sobą mniejsze ograniczenie
                auto [min_val, min_poz] = mini::ask(poz_max, i);

                if (min_val > val_max) {
                    // w tym kroku chcę użyć tego maxa

                    ile++;
                    wziete[poz_max] = true;
                    maxi::add(poz_max, -2 * INF);
                    tab[poz_max] -= 2 * INF;

                    mini::add(poz_max, i, -val_max);
                    last_wys -= val_max;
                }
                else {
                    // sprawdzam, czy za tym maxem przynajmniej nie ma coś lepszego
                    auto [drugi_max_val, drugi_max_poz] = maxi::ask(min_poz + 1, i);
                    if (drugi_max_val < min_val) {
                        // chce użyć tego pierwszego maxa

                        if (min_val <= 0) {
                            ok = false;
                            break;
                        }

                        ile++;
                        wziete[poz_max] = true;
                        maxi::add(poz_max, -2 * INF);
                        tab[poz_max] -= 2 * INF;

                        // mini::add(poz_max, min_poz - 1, -val_max);
                        mini::add(min_poz, i, -min_val);
                        last_wys -= min_val;
                    }
                    else {
                        // chce użyć drugiego?
                        auto [drugi_min_val, drugi_min_poz] = mini::ask(drugi_max_poz, i);
                        if (drugi_min_val <= drugi_max_val) {
                            // na pewni nie użyję już nigdy pierwszego maxa
                            maxi::add(poz_max, -2 * INF);
                        }
                        else {
                            // po prostu używam drugiego
                            if (drugi_max_val <= 0) {
                                ok = false;
                                break;
                            }

                            ile++;
                            wziete[drugi_max_poz] = true;
                            maxi::add(drugi_max_poz, -2 * INF);
                            tab[drugi_max_poz] -= 2 * INF;

                            mini::add(drugi_max_poz, i, -drugi_max_val);
                            last_wys -= drugi_max_val;
                        }
                    }
                }
            }
        }
        if (not ok) {
            return false;
        }

        if (ile < k) {
            for (int i = 1; i <= n; i++) {
                if (tab[i] >= 0) {
                    wziete[i] = true;
                    ile++;
                    if (ile == k)
                        break;
                }
            }

#ifdef DEBUG
            assert(ile == k);
#endif
        }

        // jeżeli odpowiedź istnieje to mam poprawnie wypełniony wektor wziete
        return true;
    }
};

ll psoms(vi& wzi) {
    ll ret = 0;
    ll pref = 0;

    for (int i = 1; i <= n; i++) {
        pref = max(0LL, pref + (wzi[i] ? A[i] : B[i]));
        ret = max(ret, pref);
    }

    return ret;
}

void solve() {
#ifdef TESTRUN
    n = 100000;
    k = n / 2;

    int mld = 1e9;
    for (int i = 1; i <= n; i++)
        A[i] = losuj(-mld, mld);

    for (int i = 1; i <= n; i++)
        A[i] = losuj(-mld, mld);

#else
    cin >> n >> k;


    for (int i = 1; i <= n; i++)
        cin >> A[i];

    for (int i = 1; i <= n; i++)
        cin >> B[i];
#endif
    wziete.resize(n + 1);

    int dobre = 0;
    for (int i = 1; i <= n; i++)
        dobre += A[i] <= B[i];

    ll L = -1; // Do takiej granicy ich nie doprowadzę
    ll R = 1ll * n * INF; // ale do takiej już potrafię

    if (dobre < k) {
        swapped = true;
        for (int i = 1; i <= n; i++)
            swap(A[i], B[i]);

        dobre = n - dobre;
        k = n - k;
    }

    // auto& oracle = (dobre >= k ? case_odejmuj::moge : case_dodawaj::moge);
#ifdef DEBUG
    cerr << (dobre >= k ? "case odejmuj" : "case dodawaj") << ' ' << k << ' ' << dobre << (swapped ? " SWAPPED" : "") << endl;
#endif

    while (R - L > 1)
        (case_odejmuj::moge((R + L) / 2) ? R : L) = (R + L) / 2;

    case_odejmuj::moge(R);
    cout << R << '\n';

#ifdef DEBUG
    vi siema(n + 1);
    for(int i = 1; i <= n; i++)
        siema[i] = wziete[i];
    assert(psoms(siema) == R);
    assert(accumulate(all(siema), 0) == k);
#endif

#ifndef DEBUG
#ifndef ANADI
    for (int i = 1; i <= n; i++)
        if (not swapped)
            cout << (wziete[i] ? 'A' : 'B');
        else
            cout << (wziete[i] ? 'B' : 'A');
    cout << '\n';
#endif
#endif
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int tests = 1;
    // cin >> tests;

    for (int i = 0; i < tests; i++)
        solve();

#ifdef DEBUG
    cerr << "DEBUG!!!" << endl;
#endif

    return 0;
}