#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

namespace {

void solve() {
  int n, m, K;
  scan(n, m, K);
  string s;
  scan(s);

  vector<int> c1(n + 1);
  for (int i : rev(rep(n))) {
    c1[i] = (s[i] == '1') + c1[i + 1];
  }

  vector<int> nxt(n + 1, n);
  for (int i : rev(rep(n))) {
    nxt[i] = nxt[i + 1];
    if (s[i] == '0') {
      nxt[i] = i;
    }
  }

  auto check = [&](int x) -> bool {
    constexpr int INF = 0x3f3f3f3f;
    vector f(K + 1, vector<int>(n - x + 1, INF));
    // i+x <= n
    for (int i : rep(n - x + 1)) {
      f[1][i] = x - (c1[i] - c1[i + x]);
    }
    for (int k : rep1(2, K)) {
      auto suff = f[k - 1];
      for (int i : rev(rep(1, len(suff)))) {
        suff[i - 1] = min(suff[i - 1], suff[i]);
      }
      for (int i : rep(n - x + 1)) {
        if (const int j = nxt[i + x] + 1; j < len(suff)) {
          f[k][i] = f[1][i] + suff[j];
        }
      }
    }
    return ranges::min(f[K]) <= m;
  };

  int ok = 0;
  int ng = n + 1;
  while (ok + 1 < ng) {
    int mid = midpoint(ok, ng);
    (check(mid) ? ok : ng) = mid;
  }

  print(ok ? ok : -1);
}

}  // namespace

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

  solve();
}

#else  // __INCLUDE_LEVEL__

#include <bits/stdc++.h>

using namespace std;

template <class T>
concept tuple_like = __is_tuple_like<T>::value && !ranges::range<T>;

template <class R>
concept nstr_range = ranges::range<R> && !convertible_to<R, string_view>;

namespace std {

istream& operator>>(istream& is, tuple_like auto&& t) {
  return apply([&is](auto&... xs) -> istream& { return (is >> ... >> xs); }, t);
}

istream& operator>>(istream& is, nstr_range auto&& r) {
  for (auto&& e : r) {
    is >> e;
  }
  return is;
}

ostream& operator<<(ostream& os, tuple_like auto&& t) {
  auto f = [&os](auto&... xs) -> ostream& {
    [[maybe_unused]] auto sep = "";
    ((os << exchange(sep, " ") << xs), ...);
    return os;
  };
  return apply(f, t);
}

ostream& operator<<(ostream& os, nstr_range auto&& r) {
  auto sep = "";
  for (auto&& e : r) {
    os << exchange(sep, " ") << e;
  }
  return os;
}

#define DEF_INC_OR_DEC(op) \
  auto& operator op(tuple_like auto&& t) { \
    apply([](auto&... xs) { (op xs, ...); }, t); \
    return t; \
  } \
  auto& operator op(nstr_range auto&& r) { \
    for (auto&& e : r) { \
      op e; \
    } \
    return r; \
  }

DEF_INC_OR_DEC(++)
DEF_INC_OR_DEC(--)

#undef DEF_INC_OR_DEC

}  // namespace std

void scan(auto&&... xs) { cin >> tie(xs...); }
void print(auto&&... xs) { cout << tie(xs...) << '\n'; }

using views::drop;
using views::take;
inline constexpr auto rev = views::reverse;
inline constexpr auto len = ranges::ssize;
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }

#endif  // __INCLUDE_LEVEL__