#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
//#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
	if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
	if(x > y) x = y;
}

inline int popcnt(int x){
	return __builtin_popcount(x);
}

inline int ctz(int x){
	return __builtin_ctz(x);
}


/*ll power(ll p,int k = mod - 2){
	ll ans = 1;
	while(k){
		if(k % 2 == 1) ans = ans * p % mod;
		p = p * p % mod;
		k /= 2;	
	}
	return ans;
}*/
int n,K;
int a[250005],b[250005],output[250005],ord[250005];

namespace solver{
	int n,K;
	int a[250005],b[250005];
	ll ssum[250005];

	set <pii> C,D;
	ll cur;
	void dbg(){
		printf("cur=%lld\n",cur);
		for(pii I:C) printf("(%d,%d) ",I.first,I.second);
		printf("\n");
		for(pii I:D) printf("(%d,%d) ",I.first,I.second);
		printf("\n");
	}
	void add(int p){
	//	printf("add %d\n",p);
		if(SZ(C) < K){
			cur += b[p];
			C.insert(mkp(b[p],p));
			return;
		}else{
			auto it = C.begin();
			if(it->first < b[p]){
				cur -= it->first;
				cur += b[p];
				D.insert(mkp(it->first,it->second));
				C.erase(it);
				C.insert(mkp(b[p],p));
			}else{
				D.insert(mkp(b[p],p));
			}
		}
	}

	void del(int p){
		if(!p) return;
	//	printf("del %d\n",p);
		auto it = D.find(mkp(b[p],p));
		if(it != D.end()){
			D.erase(it);
			return;
		}
		it = C.find(mkp(b[p],p));
		assert(it != C.end());
		cur -= b[p];
		C.erase(it);
		if(D.empty()) return;
		it = prev(D.end());
		cur += it->first;
		C.insert(mkp(it->first,it->second));
		D.erase(it);
	}

	int pl,pr;
	ll eval(int l,int r){
		if(l > r) return -linf;
	//	printf("eval [%d,%d]\n",l,r);
		while(l < pl) add(--pl);
		while(r > pr) add(++pr);
		while(pl < l) del(pl++);
		while(pr > r) del(pr--);
	//	dbg();
		if(SZ(C) < K) return -linf;
		return cur - (ssum[r] - ssum[l - 1]); 
	}

	int type;//type=0 min/max
	ll ans[250005];
	int opt[250005];
	void solve(int l,int r,int L,int R){
		if(l > r) return;
		int mid = (l + r) >> 1;
		ans[mid] = -linf;opt[mid] = 1;
		rep(i,L,R){
			ll temp = eval(i,mid);
			if(temp == -linf || temp < ans[mid]) continue;
			if(temp > ans[mid] || type){
				ans[mid] = temp;
				opt[mid] = i;
			}
		}
		solve(l,mid - 1,L,opt[mid]);
		solve(mid + 1,r,opt[mid],R);
	}	
	void solve(int tp,int rev){
		if(rev){
			reverse(a + 1,a + n + 1);
			reverse(b + 1,b + n + 1);	
			tp ^= 1;		
		}
		type = tp;
		rep(i,1,n) ssum[i] = ssum[i - 1] + a[i];
		pl = 1;pr = 0;
		C.clear();D.clear();cur = 0;
		solve(1,n,1,n);
		if(rev){
			reverse(a + 1,a + n + 1);
			reverse(b + 1,b + n + 1);	
			reverse(ans + 1,ans + n + 1);
			reverse(opt + 1,opt + n + 1);
			rep(i,1,n) opt[i] = n + 1 - opt[i];		
		}
	}
}
int valid[2][250005],idx[250005],pl[250005],pr[250005];
bool cmp(int x,int y){
	return b[x] > b[y]; 
}

void cons(int l,int r){
//	printf("cons [%d,%d]\n",l,r);
	assert(r - l + 1 >= K);
	rep(i,l,r) ord[i] = i;
	sort(ord + l,ord + r + 1,cmp);
	rep(i,l,l + K - 1) output[ord[i]] = 1;
	rep(i,l + K,r){
		if(b[ord[i]] != b[ord[i - 1]]) break;
		output[ord[i]] = 1;
	}
}

int main(){
//	freopen("test.in","r",stdin);
//	freopen("test.out","w",stdout);
	scanf("%d%d",&n,&K);
	rep(i,1,n) scanf("%d",&a[i]);
	rep(i,1,n) scanf("%d",&b[i]);	
	solver::n = n;solver::K = K;
	rep(i,1,n){
		solver::a[i] = a[i];
		solver::b[i] = b[i];
	}
	solver::solve(0,0);
	ll answer = -linf;
	rep(i,1,n) chkmax(answer,solver::ans[i]);
	printf("%lld\n",answer);
	rep(i,1,n) valid[1][i] = (solver::ans[i] == answer);

	solver::solve(0,1);
	rep(i,1,n){
		valid[0][i] = (solver::ans[i] == answer);
		pl[i] = solver::opt[i];
	}
	solver::solve(1,1);
	rep(i,1,n) pr[i] = solver::opt[i];

	rep(i,1,n){
		if(valid[0][i]){
			cons(i,pl[i]);
			rep(k,pl[i] + 1,pr[i]) chkmax(idx[k],i);
		}
	}
	rep(i,1,n) if(valid[1][i] && idx[i]) cons(idx[i],i);
	rep(i,1,n) printf("%d",output[i]);
	printf("\n");
	return 0;
}