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

typedef long long ll;

const int N = 1e5 + 5;

struct node {
	mutable int l, r, op, len;

	node() {}
	node(int l, int r, int op, int len): l(l), r(r), op(op), len(len) {}

	inline bool operator<(const node &rhs) const {
		return l < rhs.l;
	}
};

int n, k, cnt, ans, a[N], p[N];

string s;

vector <int> vec[N];
set <node> st;

inline void ins(node t) {
	if (t.l > t.r) {
		return;
	}
	st.insert(t);
	if (t.op == 1 && t.len >= k) {
		++cnt;
	}
}

inline void del(node t) {
	st.erase(t);
	if (t.op == 1 && t.len >= k) {
		--cnt;
	}
}

int tree[N];

inline int lowbit(int p) {
	return p & (-p);
}

inline void add(int p, int val) {
	while (p <= n) {
		tree[p] += val;
		p += lowbit(p);
	}
}

inline int get_sum(int p) {
	int res = 0;
	while (p) {
		res += tree[p];
		p ^= lowbit(p);
	}
	return res;
}

inline int query(int l, int r) {
	return get_sum(r) - get_sum(l - 1);
}

inline void INS(int p, int op) {
	auto it = st.upper_bound(node(p, 0, 0, 0));
	if (it != st.end() && it -> op == op) {
		--it -> l;
		++it -> len;
		if (it -> len == k) {
			++cnt;
		}
	} else {
		if (it == st.begin()) {
			ins(node(p, p, op, 1));
		} else {
			--it;
			if (it -> op == op) {
				++it -> r;
				++it -> len;
				if (it -> len == k) {
					++cnt;
				}
			} else {
				ins(node(p, p, op, 1));
			}
		}
	}
}

int main() {
	#ifdef LOCAL
		assert(freopen("test.in", "r", stdin));
		assert(freopen("test.out", "w", stdout));
	#endif
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	cin >> n >> k;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
		vec[a[i]].emplace_back(i);
	}
	cin >> s;
	for (int i = 1e5; i; --i) {
		for (auto p: vec[i]) {
			add(p, 1);
			int op = s[p - 1] - '0';
			auto it = st.upper_bound(node(p, 0, 0, 0));
			if (it == st.begin()) {
				INS(p, op);
				continue;
			}
			node t = *--it;
			if (it -> r < p) {
				INS(p, op);
				continue;
			}
			del(t);
			if (op == t.op) {
				++t.len;
				ins(t);
			} else {
				ins(node(t.l, p - 1, t.op, query(t.l, p - 1)));
				ins(node(p + 1, t.r, t.op, query(p + 1, t.r)));
				INS(p, op);
			}
		}
		if (cnt) {
			ans = i;
			break;
		}
	}
	cout << ans << "\n";
	return 0;
}