#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (int)(b) - 1; i >= (int)(a); --i)

#define all(v) begin(v), end(v)

using namespace std;

using ll = long long;

constexpr ll inf = 1e18;

template<class T, class U> bool chmin(T& a, const U& b) { return a > b ? a = b, true : false; }
template<class T, class U> bool chmax(T& a, const U& b) { return a < b ? a = b, true : false; }

class BinaryIndexedTree {
    int n;
    vector<ll> dat;

public:
    BinaryIndexedTree(int n) : n(n), dat(n + 1) {}
    void add(int k, ll x) {
        ++k;
        while (k <= n) {
            dat[k] += x;
            k += k & -k;
        }
    }
    ll sum(int k) const {
        ll res = 0;
        while (k > 0) {
            res += dat[k];
            k -= k & -k;
        }
        return res;
    }
    ll sum(int l, int r) const {
        return sum(r) - sum(l);
    }
};

int main() {
    int N, K; cin >> N >> K;
    vector<ll> C(N), V(N);
    rep (i, N) cin >> C[i];
    rep (i, N) cin >> V[i];
    vector<ll> CC(N + 1);
    rep (i, N) CC[i + 1] = CC[i] + C[i];

    int cl = 0, cr = 0;
    ll csm = 0;
    set<pair<ll, ll>> st1, st2;
    vector<ll> ans(N);
    int cur = 0;
    auto add = [&](int i) { 
        if (st1.size() < K) {
            csm += V[i];
            st1.emplace(V[i], i);
            ans[i] -= cur;
        }
        else if (st1.begin()->first >= V[i]) {
            st2.emplace(V[i], i);
        }
        else {
            csm += V[i] - st1.begin()->first;
            st2.insert(*st1.begin());
            ans[st1.begin()->second] += cur;
            st1.erase(st1.begin());
            st1.emplace(V[i], i);
            ans[i] -= cur;
        }
    };
    auto del = [&](int i) {
        if (st2.empty()) {
            csm -= V[i];
            ans[i] += cur;
            st1.erase({V[i], i});
        }
        else if (st1.count({V[i], i})) {
            csm -= V[i];
            ans[i] += cur;
            st1.erase({V[i], i});
            csm += st2.rbegin()->first;
            ans[st2.rbegin()->second] -= cur;
            st1.insert(*st2.rbegin());
            st2.erase(--st2.end());
        }
        else {
            st2.erase({V[i], i});
        }
    };
    auto calc = [&](int l, int r) -> ll {
        if (r - l < 0) return -inf;
        while (cl > l) add(--cl);
        while (cr < r) add(cr++);
        while (cl < l) del(cl++);
        while (cr > r) del(--cr);
        if (r - l < K) return -inf;
        return csm - (CC[r] - CC[l]);
    };

    vector<vector<int>> R(N);
    vector<ll> mx(N, -inf);
    rep (i, N + 1) {
        if (chmax(mx[0], calc(0, i))) R[0] = {i};
        else if (mx[0] == calc(0, i)) R[0].push_back(i);
    }
    for (int w = 1 << 20; w >= 1; w /= 2) {
        for (int i = w; i < N; i += w * 2) {
            int l = R[i - w].empty() ? 0 : R[i - w].back();
            int r = i + w < N && !R[i + w].empty() ? R[i + w].front() : N;
            chmax(l, i + K);
            rep2 (j, l, r + 1) {
                if (chmax(mx[i], calc(i, j))) R[i] = {j};
                else if (mx[i] == calc(i, j)) R[i].push_back(j);
            }
        }
    }
    ll ans1 = *max_element(all(mx));
    cout << ans1 << endl;

    {
        vector<ll> vs = V;
        sort(all(vs));
        vs.erase(unique(all(vs)), vs.end());
        rep (i, N) V[i] = lower_bound(all(vs), V[i]) - vs.begin();
        int cl = 0, cr = 0;
        vector<ll> ans(N);
        BinaryIndexedTree bit1(N), bit2(N), bit3(N);
        auto add = [&](int i) {
            ans[i] -= bit2.sum(V[i] + 1);
            bit1.add(V[i], 1);
            bit3.add(V[i], vs[V[i]]);
        };
        auto del = [&](int i) {
            ans[i] += bit2.sum(V[i] + 1);
            bit1.add(V[i], -1);
            bit3.add(V[i], -vs[V[i]]);
        };
        auto calc = [&](int l, int r) {
            while (cl > l) add(--cl);
            while (cr < r) add(cr++);
            while (cl < l) del(cl++);
            while (cr > r) del(--cr);
        };
        int j = 0;
        rep (i, N) if (mx[i] == ans1) {
            j -= 100;
            chmax(j, i + K);
            for (; j <= N; ++j) {
                calc(i, j);
                int ok = 0, ng = N + 1;
                while (ng - ok > 1) {
                    int mid = (ok + ng) / 2;
                    if (bit1.sum(mid, N) >= K) ok = mid;
                    else ng = mid;
                }
                ll s = 0;
                s += bit3.sum(ok + 1, N);
                s += (K - bit1.sum(ok + 1, N)) * vs[ok];
                s -= CC[j] - CC[i];
                if (s == ans1) bit2.add(ok, 1);
                else if (j > R[i].back() + 30) break;
            }
        }
        calc(0, 0);
        rep (i, N) cout << (ans[i] != 0);
        cout << endl;
    }
}