#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;
}*/
struct dds{
	int sgn;
	priority_queue <pii> C,D;
	int sz;
	void ins(pii val){
		sz++;
		val.first *= sgn;
		C.push(val);
	}
	void del(pii val){
		sz--;
		val.first *= sgn;
		D.push(val);
	}
	pii eval(){
		while(!C.empty() && !D.empty() && C.top() == D.top()){
			C.pop();
			D.pop();
		}
		assert(!C.empty());
		pii ret = C.top();
		ret.first *= sgn;
		return ret;
	}
	int any(){
		while(!C.empty() && !D.empty() && C.top() == D.top()){
			C.pop();
			D.pop();
		}
		return !C.empty();		
	}
	void clr(){
		while(!C.empty()) C.pop();
		while(!D.empty()) D.pop();
		sz = 0;
	}
};

struct ds{
	int b[250005],tag[250005];
	int K;
	dds C,D;
	ll cur;	
	ds(){
		C.sgn = -1;
		D.sgn = 1;
	}
	void add(int p){
	//	printf("add %d\n",p);
		if(C.sz < K){
			cur += b[p];
			C.ins(mkp(b[p],p));
			tag[p] = 1;
			return;
		}else{
			pii Mn = C.eval();
			if(Mn.first < b[p]){
				cur -= Mn.first;
				cur += b[p];
				tag[Mn.second] = 0;
				D.ins(Mn);
				C.del(Mn);
				C.ins(mkp(b[p],p));
				tag[p] = 1;
			}else{
				D.ins(mkp(b[p],p));
			}
		}
	}

	void del(int p){
		if(!p) return;
		if(!tag[p]){
			D.del(mkp(b[p],p));
			return;
		}
		cur -= b[p];
		C.del(mkp(b[p],p));
		tag[p] = 0;
		if(D.any()){
			pii Mx = D.eval();
			tag[Mx.second] = 1;
			D.del(Mx);
			C.ins(Mx);
			cur += Mx.first;
		}
	}

	void clr(){
		C.clr();D.clr();
		cur = 0;
		memset(tag,0,sizeof(tag));
	}
	ll eval(){
		if(C.sz < K) return -linf;
		return cur;
	}
	int kth(){
		assert(C.sz >= K);
		return C.eval().first;
	}
};

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];

	ds SS;
	int pl,pr;
	ll eval(int l,int r){
		if(l > r) return -linf;
	//	printf("eval [%d,%d]\n",l,r);
		while(l < pl) SS.add(--pl);
		while(r > pr) SS.add(++pr);
		while(pl < l) SS.del(pl++);
		while(pr > r) SS.del(pr--);
	//	dbg();
		return SS.eval() - (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;
		SS.clr();
		SS.K = K;
		rep(i,1,n) SS.b[i] = b[i];
		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];
int ST[20][250005];
inline void chk(int l,int r,int C){
	if(l > r) return;
//	printf("chk [%d,%d]\n",l,r);
	int x = __lg(r - l + 1);
	chkmax(ST[x][l],C);
	chkmax(ST[x][r - (1 << x) + 1],C);
}

set <pii> R;
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) printf("%d",valid[1][i]);
	printf("\n");
	rep(i,1,n) printf("%d [%d,%d]\n",valid[0][i],pl[i],pr[i]);
	printf("\n");*/
	ds SS;
	SS.K = K;
	SS.clr();
	rep(i,1,n) SS.b[i] = b[i];
	int sr = n;
	per(l,n,1){
		SS.add(l);
		R.insert(mkp(b[l],l));
		
		if(!valid[0][l]) continue;
//		printf("l=%d\n",l);
		while(sr > pl[l]){
//			printf("l=%d sr=%d b[sr]=%d\n",l,sr,b[sr]);
			SS.del(sr);
			R.erase(mkp(b[sr],sr));
			sr--;
		}
		
		int lim = SS.kth();
//		printf("lim=%d\n",lim);
		while(!R.empty()){
			auto it = prev(R.end());
			if(it->first >= lim){
				output[it->second] = 1;
				R.erase(it);
			}else{
				break;
			}
		}
	}

	rep(i,1,n) if(valid[0][i]) chk(pl[i] + 1,pr[i],i);
//	printf("fin\n");
	per(i,17,1){
		rep(j,1,n){
			if(j + (1 << i) - 1 > n) break;
			chkmax(ST[i - 1][j],ST[i][j]);
			chkmax(ST[i - 1][j + (1 << (i - 1))],ST[i][j]);
		}
	}
	rep(i,1,n) idx[i] = ST[0][i];
//	rep(i,1,n) printf("%d ",idx[i]);
//	printf("\n");
	int sl = 1;
	R.clear();SS.clr();
	rep(r,1,n){
		SS.add(r);
		R.insert(mkp(b[r],r));
		if(!valid[1][r] || !idx[r]) continue;
		while(sl < idx[r]){
			SS.del(sl);
			R.erase(mkp(b[sl],sl));
			sl++;
		}
		int lim = SS.kth();
//		printf("lim=%d\n",lim);
		while(!R.empty()){
			auto it = prev(R.end());
			if(it->first >= lim){
				output[it->second] = 1;
				R.erase(it);
			}else{
				break;
			}
		}
	}
	rep(i,1,n) printf("%d",output[i]);
	printf("\n");
	return 0;
}